openlcb_types.h

Go to the documentation of this file.

 
// This is a guard condition so that contents of this file are not included
// more than once.
#ifndef __OPENLCB_OPENLCB_TYPES__
#define __OPENLCB_OPENLCB_TYPES__
 
#include <stdbool.h>
#include <stdint.h>
 
#if __has_include("openlcb_user_config.h")
#include "openlcb_user_config.h"
#elif __has_include("../../openlcb_user_config.h")
#include "../../openlcb_user_config.h"
#elif __has_include("../../../openlcb_user_config.h")
#include "../../../openlcb_user_config.h"
#else
#error "openlcb_user_config.h not found. Copy templates/openlcb_user_config.h to your project include path."
#endif
 
#ifdef  __cplusplus
  extern "C" {
#endif /* __cplusplus */
 
#ifndef USER_DEFINED_BASIC_BUFFER_DEPTH
#error "USER_DEFINED_BASIC_BUFFER_DEPTH must be defined in openlcb_user_config.h"
#endif
 
#ifndef USER_DEFINED_DATAGRAM_BUFFER_DEPTH
#error "USER_DEFINED_DATAGRAM_BUFFER_DEPTH must be defined in openlcb_user_config.h"
#endif
 
#ifndef USER_DEFINED_SNIP_BUFFER_DEPTH
#error "USER_DEFINED_SNIP_BUFFER_DEPTH must be defined in openlcb_user_config.h"
#endif
 
#ifndef USER_DEFINED_STREAM_BUFFER_DEPTH
#error "USER_DEFINED_STREAM_BUFFER_DEPTH must be defined in openlcb_user_config.h"
#endif
 
#ifndef USER_DEFINED_NODE_BUFFER_DEPTH
#error "USER_DEFINED_NODE_BUFFER_DEPTH must be defined in openlcb_user_config.h"
#endif
 
#ifndef USER_DEFINED_CDI_LENGTH
#error "USER_DEFINED_CDI_LENGTH must be defined in openlcb_user_config.h"
#endif
 
#ifndef USER_DEFINED_FDI_LENGTH
#error "USER_DEFINED_FDI_LENGTH must be defined in openlcb_user_config.h"
#endif
 
#ifndef USER_DEFINED_PRODUCER_COUNT
#error "USER_DEFINED_PRODUCER_COUNT must be defined in openlcb_user_config.h"
#endif
 
#ifndef USER_DEFINED_PRODUCER_RANGE_COUNT
#error "USER_DEFINED_PRODUCER_RANGE_COUNT must be defined in openlcb_user_config.h"
#endif
 
#ifndef USER_DEFINED_CONSUMER_COUNT
#error "USER_DEFINED_CONSUMER_COUNT must be defined in openlcb_user_config.h"
#endif
 
#ifndef USER_DEFINED_CONSUMER_RANGE_COUNT
#error "USER_DEFINED_CONSUMER_RANGE_COUNT must be defined in openlcb_user_config.h"
#endif
 
 
#ifndef USER_DEFINED_TRAIN_NODE_COUNT
#error "USER_DEFINED_TRAIN_NODE_COUNT must be defined in openlcb_user_config.h"
#endif
 
#ifndef USER_DEFINED_MAX_LISTENERS_PER_TRAIN
#error "USER_DEFINED_MAX_LISTENERS_PER_TRAIN must be defined in openlcb_user_config.h"
#endif
 
#ifndef USER_DEFINED_MAX_TRAIN_FUNCTIONS
#error "USER_DEFINED_MAX_TRAIN_FUNCTIONS must be defined in openlcb_user_config.h"
#endif
 
 // end of user_config_constants
 
#define LEN_CONFIG_MEM_OPTIONS_DESCRIPTION (64 - 1)
 
#define LEN_CONFIG_MEM_ADDRESS_SPACE_DESCRIPTION (60 - 1)
 
#define NULL_NODE_ID 0x000000000000
 
#define NULL_EVENT_ID 0x0000000000000000
 
#define LEN_SNIP_NAME_BUFFER 41
 
#define LEN_SNIP_MODEL_BUFFER 41
 
#define LEN_SNIP_HARDWARE_VERSION_BUFFER 21
 
#define LEN_SNIP_SOFTWARE_VERSION_BUFFER 21
 
#define LEN_SNIP_USER_NAME_BUFFER 63
 
#define LEN_SNIP_USER_DESCRIPTION_BUFFER 64
 
#define LEN_SNIP_USER_DATA (LEN_SNIP_USER_NAME_BUFFER + LEN_SNIP_USER_DESCRIPTION_BUFFER)
 
#define LEN_SNIP_VERSION 1
 
#define LEN_SNIP_USER_VERSION 1
 
#define LEN_SNIP_STRUCTURE 264
 
#define LEN_MESSAGE_BYTES_BASIC 16
 
#define LEN_MESSAGE_BYTES_DATAGRAM 72
 
#define LEN_MESSAGE_BYTES_SNIP 256
 
#define LEN_MESSAGE_BYTES_STREAM 512
 
#define LEN_EVENT_ID 8
 
#define LEN_MESSAGE_BUFFER (USER_DEFINED_BASIC_BUFFER_DEPTH + USER_DEFINED_DATAGRAM_BUFFER_DEPTH + USER_DEFINED_SNIP_BUFFER_DEPTH + USER_DEFINED_STREAM_BUFFER_DEPTH)
 
#define LEN_DATAGRAM_MAX_PAYLOAD 64
 
#define LEN_EVENT_PAYLOAD LEN_MESSAGE_BYTES_SNIP
 
 // end of buffer_size_constants
 
    typedef enum {
 
        BASIC,      
        DATAGRAM,   
        SNIP,       
        STREAM      
    } payload_type_enum;
 
    typedef enum {
 
        EVENT_STATUS_UNKNOWN,   
        EVENT_STATUS_SET,       
        EVENT_STATUS_CLEAR      
    } event_status_enum;
 
    typedef enum {
 
        ADDRESS_SPACE_IN_BYTE_1 = 0,    
        ADDRESS_SPACE_IN_BYTE_6 = 1     
    } space_encoding_enum;
 
    typedef enum {
 
        EVENT_RANGE_COUNT_1 = 0,
        EVENT_RANGE_COUNT_2 = 2,
        EVENT_RANGE_COUNT_4 = 4,
        EVENT_RANGE_COUNT_8 = 8,
        EVENT_RANGE_COUNT_16 = 16,
        EVENT_RANGE_COUNT_32 = 32,
        EVENT_RANGE_COUNT_64 = 64,
        EVENT_RANGE_COUNT_128 = 128,
        EVENT_RANGE_COUNT_256 = 256,
        EVENT_RANGE_COUNT_512 = 512,
        EVENT_RANGE_COUNT_1024 = 1024,
        EVENT_RANGE_COUNT_2048 = 2048,
        EVENT_RANGE_COUNT_4096 = 4096,
        EVENT_RANGE_COUNT_8192 = 8192,
        EVENT_RANGE_COUNT_16384 = 16384,
        EVENT_RANGE_COUNT_32768 = 32768
 
    } event_range_count_enum;
 
    typedef enum {
 
        BROADCAST_TIME_EVENT_REPORT_TIME = 0,
        BROADCAST_TIME_EVENT_REPORT_DATE = 1,
        BROADCAST_TIME_EVENT_REPORT_YEAR = 2,
        BROADCAST_TIME_EVENT_REPORT_RATE = 3,
        BROADCAST_TIME_EVENT_SET_TIME = 4,
        BROADCAST_TIME_EVENT_SET_DATE = 5,
        BROADCAST_TIME_EVENT_SET_YEAR = 6,
        BROADCAST_TIME_EVENT_SET_RATE = 7,
        BROADCAST_TIME_EVENT_QUERY = 8,
        BROADCAST_TIME_EVENT_STOP = 9,
        BROADCAST_TIME_EVENT_START = 10,
        BROADCAST_TIME_EVENT_DATE_ROLLOVER = 11,
        BROADCAST_TIME_EVENT_UNKNOWN = 255
 
    } broadcast_time_event_type_enum;
 
    typedef enum {
 
        TRAIN_EMERGENCY_TYPE_ESTOP = 0,        
        TRAIN_EMERGENCY_TYPE_GLOBAL_STOP = 1,  
        TRAIN_EMERGENCY_TYPE_GLOBAL_OFF = 2    
    } train_emergency_type_enum;
 
    typedef uint8_t payload_basic_t[LEN_MESSAGE_BYTES_BASIC];
 
    typedef uint8_t payload_datagram_t[LEN_MESSAGE_BYTES_DATAGRAM];
 
    typedef uint8_t payload_snip_t[LEN_MESSAGE_BYTES_SNIP];
 
    typedef uint8_t payload_stream_t[LEN_MESSAGE_BYTES_STREAM];
 
 // end of payload_buffer_types
 
    typedef payload_basic_t openlcb_basic_data_buffer_t[USER_DEFINED_BASIC_BUFFER_DEPTH];
 
    typedef payload_datagram_t openlcb_datagram_data_buffer_t[USER_DEFINED_DATAGRAM_BUFFER_DEPTH];
 
    typedef payload_snip_t openlcb_snip_data_buffer_t[USER_DEFINED_SNIP_BUFFER_DEPTH];
 
    typedef payload_stream_t openlcb_stream_data_buffer_t[USER_DEFINED_STREAM_BUFFER_DEPTH];
 
 // end of payload_pool_types
 
    typedef uint8_t openlcb_payload_t[1];
 
    typedef uint64_t event_id_t;
 
    typedef struct {
 
        event_id_t event;           
        event_status_enum status;   
    } event_id_struct_t;
 
    typedef struct {
 
        event_id_t start_base;              
        event_range_count_enum event_count; 
    } event_id_range_t;
 
    typedef uint64_t node_id_t;
 
    typedef uint8_t event_payload_t[LEN_EVENT_PAYLOAD];
 
    typedef uint8_t configuration_memory_buffer_t[LEN_DATAGRAM_MAX_PAYLOAD];
 
    typedef struct {
 
        uint8_t hour;   
        uint8_t minute; 
        bool valid;     
    } broadcast_time_t;
 
    typedef struct {
 
        uint8_t month; 
        uint8_t day;   
        bool valid;    
    } broadcast_date_t;
 
    typedef struct {
 
        uint16_t year; 
        bool valid;    
    } broadcast_year_t;
 
    typedef struct {
 
        int16_t rate; 
        bool valid;   
    } broadcast_rate_t;
 
    typedef struct {
 
        uint64_t clock_id;       
        broadcast_time_t time;   
        broadcast_date_t date;   
        broadcast_year_t year;   
        broadcast_rate_t rate;   
        bool is_running;         
        uint32_t ms_accumulator; 
    } broadcast_clock_state_t;
 
    typedef struct {
 
        broadcast_clock_state_t state;
        bool is_consumer : 1;
        bool is_producer : 1;
        bool is_allocated : 1;
        bool query_reply_pending : 1;   
        bool sync_pending : 1;          
        uint8_t send_query_reply_state; 
        uint8_t sync_delay_ticks;       
        uint16_t report_cooldown_ticks; 
        uint8_t previous_run_state;     
        void *producer_node; 
    } broadcast_clock_t;
 
    typedef struct {
 
        bool allocated : 1;     
        bool inprocess : 1;     
        bool invalid : 1;       
        bool loopback : 1;      
    } openlcb_msg_state_t;
 
    typedef union {
 
        uint8_t assembly_ticks;     
        struct {
 
            uint8_t tick_snapshot : 5;  
            uint8_t retry_count : 3;   
        } datagram;
 
    } openlcb_msg_timer_t;
 
    typedef struct {
 
        openlcb_msg_state_t state;      
        uint16_t mti;                   
        uint16_t source_alias;          
        uint16_t dest_alias;            
        node_id_t source_id;            
        node_id_t dest_id;              
        payload_type_enum payload_type; 
        uint16_t payload_count;         
        openlcb_payload_t *payload;     
        openlcb_msg_timer_t timer;      
        uint8_t reference_count;        
    } openlcb_msg_t;
 
    typedef openlcb_msg_t openlcb_msg_array_t[LEN_MESSAGE_BUFFER];
 
    typedef struct {
 
        openlcb_msg_array_t messages;            
        openlcb_basic_data_buffer_t basic;       
        openlcb_datagram_data_buffer_t datagram; 
        openlcb_snip_data_buffer_t snip;         
        openlcb_stream_data_buffer_t stream;     
    } message_buffer_t;
 
    typedef struct {
 
        uint8_t mfg_version;                                     
        char name[LEN_SNIP_NAME_BUFFER];                         
        char model[LEN_SNIP_MODEL_BUFFER];                       
        char hardware_version[LEN_SNIP_HARDWARE_VERSION_BUFFER]; 
        char software_version[LEN_SNIP_SOFTWARE_VERSION_BUFFER]; 
        uint8_t user_version;                                    
    } user_snip_struct_t;
 
    typedef struct {
 
        bool write_under_mask_supported : 1;
        bool unaligned_reads_supported : 1;
        bool unaligned_writes_supported : 1;
        bool read_from_manufacturer_space_0xfc_supported : 1;
        bool read_from_user_space_0xfb_supported : 1;
        bool write_to_user_space_0xfb_supported : 1;
        bool stream_read_write_supported : 1;
        uint8_t high_address_space;
        uint8_t low_address_space;
        char description[LEN_CONFIG_MEM_OPTIONS_DESCRIPTION];
 
    } user_configuration_options;
 
    typedef struct {
 
        bool present : 1;
        bool read_only : 1;
        bool low_address_valid : 1;
        uint8_t address_space;      
        uint32_t highest_address;
        uint32_t low_address;       
        char description[LEN_CONFIG_MEM_ADDRESS_SPACE_DESCRIPTION];
 
    } user_address_space_info_t;
 
    typedef struct node_parameters_TAG {
 
        user_snip_struct_t snip;
        uint64_t protocol_support;              
        uint8_t consumer_count_autocreate;
        uint8_t producer_count_autocreate;
        uint8_t cdi[USER_DEFINED_CDI_LENGTH];
        uint8_t fdi[USER_DEFINED_FDI_LENGTH];
        user_address_space_info_t address_space_configuration_definition; 
        user_address_space_info_t address_space_all;                     
        user_address_space_info_t address_space_config_memory;           
        user_address_space_info_t address_space_acdi_manufacturer;       
        user_address_space_info_t address_space_acdi_user;               
        user_address_space_info_t address_space_train_function_definition_info; 
        user_address_space_info_t address_space_train_function_config_memory;   
        user_configuration_options configuration_options;
        user_address_space_info_t address_space_firmware;                 
    } node_parameters_t;
 
    typedef struct {
 
        bool running : 1;         
        uint8_t enum_index;       
        uint8_t range_enum_index; 
    } event_id_enum_t;
 
    typedef struct {
 
        uint16_t count;
        event_id_struct_t list[USER_DEFINED_CONSUMER_COUNT];
        uint16_t range_count;
        event_id_range_t range_list[USER_DEFINED_CONSUMER_RANGE_COUNT];
        event_id_enum_t enumerator;
 
    } event_id_consumer_list_t;
 
    typedef struct {
 
        uint16_t count;
        event_id_struct_t list[USER_DEFINED_PRODUCER_COUNT];
        uint16_t range_count;
        event_id_range_t range_list[USER_DEFINED_PRODUCER_RANGE_COUNT];
        event_id_enum_t enumerator;
 
    } event_id_producer_list_t;
 
    typedef struct {
 
        uint8_t run_state : 5;              
        bool allocated : 1;                 
        bool permitted : 1;                 
        bool initialized : 1;              
        bool duplicate_id_detected : 1;     
        bool openlcb_datagram_ack_sent : 1; 
        bool resend_datagram : 1;           
        bool firmware_upgrade_active : 1;   
    } openlcb_node_state_t;
 
    typedef struct {
 
        node_id_t node_id; 
        uint8_t flags;     
    } train_listener_entry_t;
 
    typedef struct train_state_TAG {
 
        uint16_t set_speed;               
        uint16_t commanded_speed;         
        uint16_t actual_speed;            
        bool estop_active;                
        bool global_estop_active;         
        bool global_eoff_active;          
        node_id_t controller_node_id;     
        uint16_t controller_alias;        
        uint8_t reserved_node_count;      
        node_id_t reserved_by_node_id;    
        uint32_t heartbeat_timeout_s;     
        uint32_t heartbeat_counter_100ms; 
        train_listener_entry_t listeners[USER_DEFINED_MAX_LISTENERS_PER_TRAIN];
        uint8_t listener_count;
        uint8_t listener_enum_index;      
        uint16_t functions[USER_DEFINED_MAX_TRAIN_FUNCTIONS]; 
        uint16_t dcc_address;    
        bool is_long_address;    
        uint8_t speed_steps;     
        struct openlcb_node_TAG *owner_node; 
    } train_state_t;
 
    typedef struct openlcb_node_TAG {
 
        openlcb_node_state_t state;
        uint64_t id;                            
        uint16_t alias;                         
        uint64_t seed;                          
        event_id_consumer_list_t consumers;
        event_id_producer_list_t producers;
        const node_parameters_t *parameters;
        uint16_t timerticks;                    
        uint64_t owner_node;                    
        openlcb_msg_t *last_received_datagram;  
        uint8_t index;                          
        struct train_state_TAG *train_state;    
    } openlcb_node_t;
 
    typedef struct {
 
        openlcb_node_t node[USER_DEFINED_NODE_BUFFER_DEPTH];
        uint16_t count; 
    } openlcb_nodes_t;
 
    typedef struct {
 
        openlcb_msg_t worker;
        payload_stream_t worker_buffer;
        openlcb_msg_t *active_msg;
 
    } openlcb_statemachine_worker_t;
 
    typedef void (*parameterless_callback_t)(void);
 
    typedef struct {
 
        openlcb_msg_t openlcb_msg;
        payload_stream_t openlcb_payload;
 
    } openlcb_stream_message_t;
 
    typedef struct {
 
        openlcb_msg_t *msg_ptr;
        uint8_t valid : 1;
        uint8_t enumerate : 1;
        openlcb_stream_message_t openlcb_msg;
 
    } openlcb_outgoing_stream_msg_info_t;
 
    typedef struct {
 
        openlcb_msg_t *msg_ptr;
        uint8_t enumerate : 1;
 
    } openlcb_incoming_msg_info_t;
 
    typedef struct {
 
        openlcb_node_t *openlcb_node;
        openlcb_incoming_msg_info_t incoming_msg_info;
        openlcb_outgoing_stream_msg_info_t outgoing_msg_info;
        uint8_t current_tick;
 
    } openlcb_statemachine_info_t;
 
    typedef struct {
 
        openlcb_msg_t openlcb_msg;
        payload_basic_t openlcb_payload;
 
    } openlcb_basic_message_t;
 
    typedef struct {
 
        openlcb_msg_t *msg_ptr;
        uint8_t valid : 1;
        uint8_t enumerate : 1;
        openlcb_basic_message_t openlcb_msg;
 
    } openlcb_outgoing_basic_msg_info_t;
 
    typedef struct {
 
        openlcb_node_t *openlcb_node;
        openlcb_outgoing_basic_msg_info_t outgoing_msg_info;
 
    } openlcb_login_statemachine_info_t;
 
    struct config_mem_operations_request_info_TAG;
 
    typedef void (*operations_config_mem_space_func_t)(openlcb_statemachine_info_t *statemachine_info, struct config_mem_operations_request_info_TAG *config_mem_operations_request_info);
 
    typedef struct config_mem_operations_request_info_TAG {
 
        const user_address_space_info_t *space_info;
        operations_config_mem_space_func_t operations_func;
 
    } config_mem_operations_request_info_t;
 
    struct config_mem_read_request_info_TAG;
 
    typedef void (*read_config_mem_space_func_t)(openlcb_statemachine_info_t *statemachine_info, struct config_mem_read_request_info_TAG *config_mem_read_request_info);
 
    typedef struct config_mem_read_request_info_TAG {
 
        space_encoding_enum encoding;
        uint32_t address;
        uint16_t bytes;
        uint16_t data_start;  
        const user_address_space_info_t *space_info;
        read_config_mem_space_func_t read_space_func;
 
    } config_mem_read_request_info_t;
 
    struct config_mem_write_request_info_TAG;
 
    typedef void (*write_config_mem_space_func_t)(openlcb_statemachine_info_t *statemachine_info, struct config_mem_write_request_info_TAG *config_mem_write_request_info);
 
    typedef struct config_mem_write_request_info_TAG {
 
        space_encoding_enum encoding;
        uint32_t address;
        uint16_t bytes;
        configuration_memory_buffer_t *write_buffer;
        uint16_t data_start;  
        const user_address_space_info_t *space_info;
        write_config_mem_space_func_t write_space_func;
 
    } config_mem_write_request_info_t;
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
 
#endif /* __OPENLCB_OPENLCB_TYPES__ */