device.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2020 ETC Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 ******************************************************************************
 * This file is a part of RDMnet. For more information, go to:
 * https://github.com/ETCLabs/RDMnet
 *****************************************************************************/
 
#ifndef RDMNET_DEVICE_H_
#define RDMNET_DEVICE_H_
 
#include <stdbool.h>
#include "etcpal/uuid.h"
#include "rdm/uid.h"
#include "rdmnet/client.h"
#include "rdmnet/message.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef int rdmnet_device_t;
#define RDMNET_DEVICE_INVALID -1
 
typedef void (*RdmnetDeviceConnectedCallback)(rdmnet_device_t                  handle,
                                              const RdmnetClientConnectedInfo* info,
                                              void*                            context);
 
typedef void (*RdmnetDeviceConnectFailedCallback)(rdmnet_device_t                      handle,
                                                  const RdmnetClientConnectFailedInfo* info,
                                                  void*                                context);
 
typedef void (*RdmnetDeviceDisconnectedCallback)(rdmnet_device_t                     handle,
                                                 const RdmnetClientDisconnectedInfo* info,
                                                 void*                               context);
 
typedef void (*RdmnetDeviceRdmCommandReceivedCallback)(rdmnet_device_t         handle,
                                                       const RdmnetRdmCommand* cmd,
                                                       RdmnetSyncRdmResponse*  response,
                                                       void*                   context);
 
typedef void (*RdmnetDeviceLlrpRdmCommandReceivedCallback)(rdmnet_device_t        handle,
                                                           const LlrpRdmCommand*  cmd,
                                                           RdmnetSyncRdmResponse* response,
                                                           void*                  context);
 
typedef void (*RdmnetDeviceDynamicUidStatusCallback)(rdmnet_device_t                       handle,
                                                     const RdmnetDynamicUidAssignmentList* list,
                                                     void*                                 context);
 
typedef struct RdmnetDeviceCallbacks
{
  RdmnetDeviceConnectedCallback              connected;                   
  RdmnetDeviceConnectFailedCallback          connect_failed;              
  RdmnetDeviceDisconnectedCallback           disconnected;                
  RdmnetDeviceRdmCommandReceivedCallback     rdm_command_received;        
  RdmnetDeviceLlrpRdmCommandReceivedCallback llrp_rdm_command_received;   
  RdmnetDeviceDynamicUidStatusCallback       dynamic_uid_status_received; 
  void* context; 
} RdmnetDeviceCallbacks;
 
typedef struct RdmnetVirtualEndpointConfig
{
  uint16_t endpoint_id;
  const EtcPalUuid* dynamic_responders;
  size_t num_dynamic_responders;
  const RdmUid* static_responders;
  size_t num_static_responders;
} RdmnetVirtualEndpointConfig;
 
#define RDMNET_VIRTUAL_ENDPOINT_INIT(endpoint_num) \
  {                                                \
    (endpoint_num), NULL, 0, NULL, 0               \
  }
 
typedef struct RdmnetPhysicalEndpointResponder
{
  RdmUid uid;
  uint16_t control_field;
  RdmUid binding_uid;
} RdmnetPhysicalEndpointResponder;
 
typedef struct RdmnetPhysicalEndpointConfig
{
  uint16_t endpoint_id;
  const RdmnetPhysicalEndpointResponder* responders;
  size_t num_responders;
} RdmnetPhysicalEndpointConfig;
 
#define RDMNET_PHYSICAL_ENDPOINT_INIT(endpoint_num) \
  {                                                 \
    (endpoint_num), NULL, 0                         \
  }
 
typedef struct RdmnetDeviceConfig
{
  /************************************************************************************************
   * Required Values
   ***********************************************************************************************/
 
  EtcPalUuid cid;
  RdmnetDeviceCallbacks callbacks;
 
  /************************************************************************************************
   * Optional Values
   ***********************************************************************************************/
 
  uint8_t* response_buf;
 
  RdmnetScopeConfig scope_config;
 
  RdmUid uid;
 
  const char* search_domain;
 
  const RdmnetPhysicalEndpointConfig* physical_endpoints;
  size_t num_physical_endpoints;
 
  const RdmnetVirtualEndpointConfig* virtual_endpoints;
  size_t num_virtual_endpoints;
 
  const RdmnetMcastNetintId* llrp_netints;
  size_t num_llrp_netints;
} RdmnetDeviceConfig;
 
#define RDMNET_DEVICE_CONFIG_DEFAULT_INIT(manu_id)                                             \
  {                                                                                            \
    {{0}}, {NULL, NULL, NULL, NULL, NULL, NULL, NULL}, NULL, RDMNET_SCOPE_CONFIG_DEFAULT_INIT, \
        {(0x8000 | manu_id), 0}, NULL, NULL, 0, NULL, 0, NULL, 0                               \
  }
 
void rdmnet_device_config_init(RdmnetDeviceConfig* config, uint16_t manufacturer_id);
void rdmnet_device_set_callbacks(RdmnetDeviceConfig*                        config,
                                 RdmnetDeviceConnectedCallback              connected,
                                 RdmnetDeviceConnectFailedCallback          connect_failed,
                                 RdmnetDeviceDisconnectedCallback           disconnected,
                                 RdmnetDeviceRdmCommandReceivedCallback     rdm_command_received,
                                 RdmnetDeviceLlrpRdmCommandReceivedCallback llrp_rdm_command_received,
                                 RdmnetDeviceDynamicUidStatusCallback       dynamic_uid_status_received,
                                 void*                                      context);
 
etcpal_error_t rdmnet_device_create(const RdmnetDeviceConfig* config, rdmnet_device_t* handle);
etcpal_error_t rdmnet_device_destroy(rdmnet_device_t handle, rdmnet_disconnect_reason_t disconnect_reason);
 
etcpal_error_t rdmnet_device_send_rdm_ack(rdmnet_device_t              handle,
                                          const RdmnetSavedRdmCommand* received_cmd,
                                          const uint8_t*               response_data,
                                          size_t                       response_data_len);
etcpal_error_t rdmnet_device_send_rdm_nack(rdmnet_device_t              handle,
                                           const RdmnetSavedRdmCommand* received_cmd,
                                           rdm_nack_reason_t            nack_reason);
etcpal_error_t rdmnet_device_send_rdm_update(rdmnet_device_t handle,
                                             uint16_t        subdevice,
                                             uint16_t        param_id,
                                             const uint8_t*  data,
                                             size_t          data_len);
etcpal_error_t rdmnet_device_send_rdm_update_from_responder(rdmnet_device_t         handle,
                                                            const RdmnetSourceAddr* source_addr,
                                                            uint16_t                param_id,
                                                            const uint8_t*          data,
                                                            size_t                  data_len);
etcpal_error_t rdmnet_device_send_status(rdmnet_device_t              handle,
                                         const RdmnetSavedRdmCommand* received_cmd,
                                         rpt_status_code_t            status_code,
                                         const char*                  status_string);
 
etcpal_error_t rdmnet_device_send_llrp_ack(rdmnet_device_t            handle,
                                           const LlrpSavedRdmCommand* received_cmd,
                                           const uint8_t*             response_data,
                                           uint8_t                    response_data_len);
etcpal_error_t rdmnet_device_send_llrp_nack(rdmnet_device_t            handle,
                                            const LlrpSavedRdmCommand* received_cmd,
                                            rdm_nack_reason_t          nack_reason);
 
etcpal_error_t rdmnet_device_add_physical_endpoint(rdmnet_device_t                     handle,
                                                   const RdmnetPhysicalEndpointConfig* endpoint_config);
etcpal_error_t rdmnet_device_add_physical_endpoints(rdmnet_device_t                     handle,
                                                    const RdmnetPhysicalEndpointConfig* endpoint_configs,
                                                    size_t                              num_endpoints);
etcpal_error_t rdmnet_device_add_virtual_endpoint(rdmnet_device_t                    handle,
                                                  const RdmnetVirtualEndpointConfig* endpoint_config);
etcpal_error_t rdmnet_device_add_virtual_endpoints(rdmnet_device_t                    handle,
                                                   const RdmnetVirtualEndpointConfig* endpoint_configs,
                                                   size_t                             num_endpoints);
etcpal_error_t rdmnet_device_remove_endpoint(rdmnet_device_t handle, uint16_t endpoint_id);
etcpal_error_t rdmnet_device_remove_endpoints(rdmnet_device_t handle,
                                              const uint16_t* endpoint_ids,
                                              size_t          num_endpoints);
 
etcpal_error_t rdmnet_device_add_static_responders(rdmnet_device_t handle,
                                                   uint16_t        endpoint_id,
                                                   const RdmUid*   responder_uids,
                                                   size_t          num_responders);
etcpal_error_t rdmnet_device_add_dynamic_responders(rdmnet_device_t   handle,
                                                    uint16_t          endpoint_id,
                                                    const EtcPalUuid* responder_ids,
                                                    size_t            num_responders);
etcpal_error_t rdmnet_device_add_physical_responders(rdmnet_device_t                        handle,
                                                     uint16_t                               endpoint_id,
                                                     const RdmnetPhysicalEndpointResponder* responders,
                                                     size_t                                 num_responders);
 
etcpal_error_t rdmnet_device_remove_static_responders(rdmnet_device_t handle,
                                                      uint16_t        endpoint_id,
                                                      const RdmUid*   responder_uids,
                                                      size_t          num_responders);
etcpal_error_t rdmnet_device_remove_dynamic_responders(rdmnet_device_t   handle,
                                                       uint16_t          endpoint_id,
                                                       const EtcPalUuid* responder_ids,
                                                       size_t            num_responders);
etcpal_error_t rdmnet_device_remove_physical_responders(rdmnet_device_t handle,
                                                        uint16_t        endpoint_id,
                                                        const RdmUid*   responder_uids,
                                                        size_t          num_responders);
 
etcpal_error_t rdmnet_device_change_scope(rdmnet_device_t            handle,
                                          const RdmnetScopeConfig*   new_scope_config,
                                          rdmnet_disconnect_reason_t disconnect_reason);
etcpal_error_t rdmnet_device_change_search_domain(rdmnet_device_t            handle,
                                                  const char*                new_search_domain,
                                                  rdmnet_disconnect_reason_t disconnect_reason);
etcpal_error_t rdmnet_device_get_scope(rdmnet_device_t handle, char* scope_str_buf, EtcPalSockAddr* static_broker_addr);
 
#ifdef __cplusplus
};
#endif
 
#endif /* RDMNET_DEVICE_H_ */