kdrive_express_access.h

Go to the documentation of this file.

//
// Copyright (c) 2002-2023 WEINZIERL ENGINEERING GmbH
// All rights reserved.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
// SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY,
// WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE
//
 
#ifndef __KDRIVE_EXPRESS_ACCESS_H__
#define __KDRIVE_EXPRESS_ACCESS_H__
 
#include "kdrive_express_config.h"
#include "kdrive_express_defs.h"
 
#define KDRIVE_MAX_TUNNEL_INFO_ITEMS            (63)     
#ifdef __cplusplus
extern "C" {
#endif
 
/*******************************
** Init
********************************/
 
kdriveExpress_API int32_t kdrive_ap_create(void);
 
kdriveExpress_API bool_t kdrive_ap_release(int32_t ap);
 
/*******************************
** Keyring
********************************/
 
kdriveExpress_API error_t kdrive_ap_set_keyring(int32_t ap, int32_t keyring);
 
/*******************************
** USB
********************************/
 
kdriveExpress_API uint32_t kdrive_ap_enum_usb(int32_t ap);
 
typedef struct usb_dev_t
{
        uint16_t ind_addr; 
        uint16_t media_tytes; 
        uint32_t internal_usb_index; 
        uint32_t usb_vendor_id; 
        uint32_t usb_product_id; 
} usb_dev_t;
 
kdriveExpress_API error_t kdrive_ap_enum_usb_ex(usb_dev_t items[], uint32_t* items_length);
 
kdriveExpress_API error_t kdrive_ap_only_enum_usb(usb_dev_t items[], uint32_t* items_length);
 
kdriveExpress_API error_t kdrive_ap_open_usb(int32_t ap, uint32_t iface_index);
 
/*******************************
** KNXnet/IP Tunneling
********************************/
 
typedef struct ip_tunn_slot_info_t
{
        uint16_t address; 
        uint16_t status;  
} ip_tunn_slot_info_t;
 
 
typedef struct ip_tunn_dev_t
{
        // ip address and network interface
        char ip_address[KDRIVE_MAX_IP_ADDRESS_LEN]; 
        char iface_address[KDRIVE_MAX_IP_ADDRESS_LEN]; 
        // device information
        char dev_name[KDRIVE_MAX_DEVICE_NAME_LEN]; 
        uint16_t ind_addr; 
        uint8_t mac_address[KDRIVE_MAC_LEN]; 
        uint8_t serial_number[KDRIVE_SN_LEN]; 
        bool_t prog_mode_enabled; 
        // security information
        bool_t is_security_supported; 
        bool_t is_tunneling_secure; 
        bool_t is_management_secure; 
        // tunnling slot information
        // optional (When the device not support it then slot_infos_count is 0)
        uint16_t slot_infos_count; 
        ip_tunn_slot_info_t slot_infos[KDRIVE_MAX_TUNNEL_INFO_ITEMS]; 
} ip_tunn_dev_t;
 
kdriveExpress_API error_t kdrive_ap_enum_ip_tunn(int32_t ap,
        ip_tunn_dev_t items[],
        uint32_t* items_length);
 
 
kdriveExpress_API error_t kdrive_ap_read_ip_tunn_device_info(int32_t ap,
        const char* ip_address,
        uint16_t port,
        const char* iface_address,
        ip_tunn_dev_t* device_info);
 
kdriveExpress_API error_t kdrive_ap_open_ip_tunn(int32_t ap, const char* ip_address, uint16_t port, const char* iface_address);
 
kdriveExpress_API error_t kdrive_ap_open_ip_tunn_nat(int32_t ap, const char* ip_address, uint16_t port, const char* iface_address);
 
kdriveExpress_API error_t kdrive_ap_open_ip(int32_t ap, const char* ip_address);
 
kdriveExpress_API error_t kdrive_ap_open_ip_ex(int32_t ap, const char* ip_address, const char* iface_address);
 
kdriveExpress_API error_t kdrive_ap_open_ip_nat(int32_t ap, const char* ip_address, const char* iface_address);
 
kdriveExpress_API error_t kdrive_ap_is_ip_tunn_secure(int32_t ap, bool_t* secured);
 
kdriveExpress_API error_t kdrive_ap_set_ip_tunn_auth_code(int32_t ap, const char* authentication_code);
 
kdriveExpress_API error_t kdrive_ap_set_ip_tunn_credentials(int32_t ap, uint8_t user_id, const char* password);
 
kdriveExpress_API error_t kdrive_ap_set_ip_tunn_user_id(int32_t ap, uint8_t user_id);
 
kdriveExpress_API error_t kdrive_ap_get_ip_tunn_user_id(int32_t ap, uint8_t* user_id);
 
kdriveExpress_API error_t kdrive_ap_set_ip_tunn_requested_ia(int32_t ap, uint16_t address);
 
/*******************************
** KNXnet/IP Routing
********************************/
 
typedef struct ip_rout_info_t
{
        char multicast_address[KDRIVE_MAX_IP_ADDRESS_LEN]; 
        char iface_address[KDRIVE_MAX_IP_ADDRESS_LEN]; 
        uint32_t number_of_devices; 
} ip_rout_info_t;
 
kdriveExpress_API error_t kdrive_ap_enum_ip_rout(int32_t ap,
        ip_rout_info_t items[],
        uint32_t* items_length);
 
kdriveExpress_API error_t kdrive_ap_open_ip_rout(int32_t ap, const char* multicast_address, const char* iface_address, bool_t secured);
 
kdriveExpress_API error_t kdrive_ap_is_ip_rout_secure(int32_t ap, bool_t* secured);
 
kdriveExpress_API error_t kdrive_ap_set_ip_rout_backbone_key(int32_t ap, const char* key);
 
/*******************************
** Serial FT1.2
********************************/
 
kdriveExpress_API error_t kdrive_ap_open_serial_ft12(int32_t ap, const char* serial_device);
 
/*******************************
** TinySerial
********************************/
 
kdriveExpress_API error_t kdrive_ap_open_tiny_serial(int32_t ap, const char* serial_device);
 
/*******************************
** Connection Management
********************************/
 
kdriveExpress_API error_t kdrive_ap_close(int32_t ap);
 
kdriveExpress_API bool_t kdrive_ap_is_open(int32_t ap);
 
/*******************************
** Send KNX Telegrams
********************************/
 
kdriveExpress_API error_t kdrive_ap_send(int32_t ap, const uint8_t telegram[], uint32_t telegram_len);
 
kdriveExpress_API error_t kdrive_ap_group_write(int32_t ap, uint16_t address, const uint8_t* value, uint32_t bits);
 
kdriveExpress_API error_t kdrive_ap_group_read(int32_t ap, uint16_t address);
 
kdriveExpress_API error_t kdrive_ap_group_response(int32_t ap, uint16_t address, const uint8_t* value, uint32_t bits);
 
kdriveExpress_API uint32_t kdrive_ap_read_group_object(int32_t ap, uint16_t address,
        uint8_t telegram[], uint32_t telegram_len, uint32_t timeout);
 
/*******************************
** Receive KNX Telegrams
********************************/
 
kdriveExpress_API error_t kdrive_ap_enable_queue(int32_t ap, bool_t enabled);
 
kdriveExpress_API uint32_t kdrive_ap_receive(int32_t ap,
        uint8_t telegram[], uint32_t telegram_len, uint32_t timeout);
 
/*******************************
** KNX Telegram Callback
********************************/
 
typedef void (*kdrive_ap_telegram_callback)(const uint8_t telegram[], uint32_t telegram_len, void* user_data);
 
kdriveExpress_API error_t kdrive_ap_register_telegram_callback(int32_t ap,
        kdrive_ap_telegram_callback c, void* user_data, uint32_t* key);
 
kdriveExpress_API error_t kdrive_ap_register_sec_telegram_callback(int32_t ap,
        kdrive_ap_telegram_callback c, void* user_data, uint32_t* key);
 
kdriveExpress_API error_t kdrive_ap_remove_telegram_callback(int32_t ap, uint32_t key);
 
/*******************************
** Telegram Attributes
********************************/
 
kdriveExpress_API error_t kdrive_ap_get_dest(const uint8_t telegram[],
        uint32_t telegram_len, uint16_t* address);
 
kdriveExpress_API error_t kdrive_ap_get_src(const uint8_t telegram[],
        uint32_t telegram_len, uint16_t* address);
 
kdriveExpress_API error_t kdrive_ap_get_apci(const uint8_t telegram[],
        uint32_t telegram_len, uint16_t* apci);
 
kdriveExpress_API error_t kdrive_ap_get_message_code(const uint8_t telegram[],
        uint32_t telegram_len, uint8_t* message_code);
 
kdriveExpress_API error_t kdrive_ap_get_serial_number(const uint8_t telegram[],
        uint32_t telegram_len, uint8_t sn[KDRIVE_SN_LEN]);
 
/*******************************
** Group Values
********************************/
 
kdriveExpress_API bool_t kdrive_ap_is_group(const uint8_t telegram[], uint32_t telegram_len);
 
kdriveExpress_API bool_t kdrive_ap_is_group_write(const uint8_t telegram[], uint32_t telegram_len);
 
kdriveExpress_API bool_t kdrive_ap_is_group_read(const uint8_t telegram[], uint32_t telegram_len);
 
kdriveExpress_API bool_t kdrive_ap_is_group_response(const uint8_t telegram[], uint32_t telegram_len);
 
kdriveExpress_API error_t kdrive_ap_get_group_data(const uint8_t telegram[],
        uint32_t telegram_len, uint8_t* data, uint32_t* data_len);
 
kdriveExpress_API error_t kdrive_ap_is_compressed_group_data(const uint8_t telegram[],
        uint32_t telegram_len, bool_t* is_commpressed);
 
/*******************************
** Data Security
********************************/
 
enum data_sec_t
{
        Off  = 0x00, 
        On   = 0x01, 
        Auto = 0x03  
};
 
kdriveExpress_API error_t kdrive_ap_set_data_sec(int32_t ap, enum data_sec_t dataSec);
 
kdriveExpress_API error_t kdrive_ap_get_data_sec(int32_t ap, enum data_sec_t* dataSec);
 
kdriveExpress_API error_t kdrive_ap_set_data_sec_own_seq_num(int32_t ap, const uint8_t seq_num[6]);
 
kdriveExpress_API error_t kdrive_ap_set_data_sec_device_seq_num(int32_t ap, uint16_t address, const uint8_t seq_num[6]);
 
kdriveExpress_API bool_t kdrive_ap_is_data_sec(const uint8_t telegram[], uint32_t telegram_len);
 
/*******************************
** Access Port Properties
********************************/
 
kdriveExpress_API error_t kdrive_ap_get_layer(int32_t ap, uint16_t* layer);
 
kdriveExpress_API error_t kdrive_ap_set_layer(int32_t ap, uint16_t layer);
 
kdriveExpress_API error_t kdrive_ap_get_ind_addr(int32_t ap, uint16_t* address);
 
kdriveExpress_API error_t kdrive_ap_set_ind_addr(int32_t ap, uint16_t address);
 
kdriveExpress_API error_t kdrive_ap_get_rf_domain_addr(int32_t ap, uint8_t da[KDRIVE_DA_LEN]);
 
kdriveExpress_API error_t kdrive_ap_set_rf_domain_addr(int32_t ap, const uint8_t da[KDRIVE_DA_LEN]);
 
kdriveExpress_API error_t kdrive_ap_get_serial_no(int32_t ap, uint8_t sn[KDRIVE_SN_LEN]);
 
kdriveExpress_API error_t kdrive_ap_set_serial_no(int32_t ap, const uint8_t sn[KDRIVE_SN_LEN]);
 
kdriveExpress_API error_t kdrive_ap_get_tunnel_ind_addr(int32_t ap, uint16_t* address);
 
kdriveExpress_API error_t kdrive_ap_set_tunnel_ind_addr(int32_t ap, uint16_t address);
 
kdriveExpress_API error_t kdrive_ap_get_additional_ind_addr(int32_t ap, uint16_t addresses[], uint32_t* addresses_len);
 
kdriveExpress_API error_t kdrive_ap_set_additional_ind_addr(int32_t ap, const uint16_t addresses[], uint16_t addresses_len);
 
kdriveExpress_API error_t kdrive_ap_get_filter_dest_addr(int32_t ap, bool_t* is_enabled);
 
kdriveExpress_API error_t kdrive_ap_set_filter_dest_addr(int32_t ap, bool_t enable);
 
kdriveExpress_API error_t kdrive_ap_get_filter_rf_domain_addr(int32_t ap, bool_t* is_enabled);
 
kdriveExpress_API error_t kdrive_ap_set_filter_rf_domain_addr(int32_t ap, bool_t enable);
 
kdriveExpress_API error_t kdrive_ap_get_bus_state(int32_t ap, bool_t use_cache, uint32_t* bus_state);
 
kdriveExpress_API error_t kdrive_ap_get_max_apdu_length(int32_t ap, uint32_t* max_apdu_length);
 
/*******************************
** Packet Trace
********************************/
 
kdriveExpress_API error_t kdrive_ap_packet_trace_connect(int32_t ap);
 
kdriveExpress_API error_t kdrive_ap_packet_trace_disconnect(int32_t ap);
 
typedef void(*kdrive_ap_packet_trace_callback)(const uint8_t telegram[], uint32_t telegram_len, int32_t direction, void* user_data);
 
kdriveExpress_API error_t kdrive_ap_set_packet_trace_callback(int32_t ap, kdrive_ap_packet_trace_callback c, void* user_data);
 
#ifdef __cplusplus
}
#endif
 
#endif /* __KDRIVE_EXPRESS_ACCESS_H__ */