rdm_responder.h

Go to the documentation of this file.

/*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 *
 * rdm_responder.h
 * Copyright (C) 2015 Simon Newton
 */

#ifndef FIRMWARE_SRC_RDM_RESPONDER_H_
#define FIRMWARE_SRC_RDM_RESPONDER_H_

#include <stdbool.h>
#include <stdint.h>

#include "system_config.h"

#include "peripheral/ports/plib_ports.h"
#include "rdm.h"
#include "rdm_frame.h"
#include "rdm_handler.h"

#ifdef __cplusplus
extern "C" {
#endif

extern const char MANUFACTURER_LABEL[];

typedef int (*PIDCommandHandler)(const RDMHeader *incoming_header,
                                 const uint8_t *param_data);

typedef struct {
  uint8_t pdl_size;  
  uint8_t data_type;  
  uint8_t command_class;  
  uint8_t unit;  
  uint8_t prefix;  
  uint32_t min_valid_value;  
  uint32_t max_valid_value;  
  uint32_t default_value;  
  const char *description;  
} ParameterDescription;

typedef struct {
  uint16_t pid;

  PIDCommandHandler get_handler;

  uint8_t get_param_size;

  PIDCommandHandler set_handler;
} PIDDescriptor;

typedef struct {
  RDMProductDetail ids[MAX_PRODUCT_DETAILS];
  uint8_t size;  
} ProductDetailIds;

typedef struct {
  const char *description;

  uint16_t slot_label_id;

  uint8_t slot_type;

  uint8_t default_value;
} SlotDefinition;

typedef struct {
  uint16_t dmx_footprint;

  const char *description;

  const SlotDefinition *slots;

  uint16_t slot_count;
} PersonalityDefinition;

typedef struct {
  const char *description;  
  int16_t range_maximum_value;  
  int16_t range_minimum_value;  
  int16_t normal_maximum_value;  
  int16_t normal_minimum_value;  
  uint8_t recorded_value_support;  
  RDMSensorType type;  
  RDMUnit unit;  
  RDMPrefix prefix;  
} SensorDefinition;

typedef struct {
  int16_t present_value;  
  int16_t lowest_value;  
  int16_t highest_value;  
  int16_t recorded_value;  

  RDMNackReason nack_reason;

  bool should_nack;  
} SensorData;

typedef struct {
  const PIDDescriptor *descriptors;

  const SensorDefinition *sensors;

  const PersonalityDefinition *personalities;

  const char *software_version_label;  
  const char *manufacturer_label;  
  const char *model_description;  
  const char *default_device_label;  

  const ProductDetailIds *product_detail_ids;

  unsigned int descriptor_count;

  unsigned int personality_count;

  uint32_t software_version;  
  uint16_t model_id;  
  RDMProductCategory product_category;  

  uint8_t sensor_count;  
} ResponderDefinition;

typedef struct {
  char device_label[RDM_DEFAULT_STRING_SIZE];  
  uint8_t uid[UID_LENGTH];  

  const ResponderDefinition *def;

  SensorData *sensors;

  uint16_t dmx_start_address;  
  uint16_t sub_device_count;  
  uint8_t current_personality;  
  uint8_t queued_message_count;  
  bool is_muted;  
  bool identify_on;  
  bool using_factory_defaults;  
  bool is_subdevice;  // true if this is a subdevice.
  bool is_managed_proxy;  // true if this is a managed proxy.
  bool is_proxied_device;  // true if this is a proxied device.
} RDMResponder;

extern RDMResponder *g_responder;

static const int RDM_RESPONDER_NO_RESPONSE = 0;

typedef struct {
  PORTS_CHANNEL identify_port;  
  PORTS_BIT_POS identify_bit;  
  PORTS_CHANNEL mute_port;  
  PORTS_BIT_POS mute_bit;  
  uint8_t uid[UID_LENGTH];  
} RDMResponderSettings;

void RDMResponder_Initialize(const RDMResponderSettings *settings);

void RDMResponder_Tasks();

void RDMResponder_SwitchResponder(RDMResponder *responder);

void RDMResponder_RestoreResponder();

void RDMResponder_InitResponder();

void RDMResponder_ResetToFactoryDefaults();

void RDMResponder_GetUID(uint8_t *uid);

int RDMResponder_HandleDUBRequest(const uint8_t *param_data,
                                  unsigned int param_data_length);

void RDMResponder_BuildHeader(const RDMHeader *incoming_header,
                              RDMResponseType response_type,
                              RDMCommandClass command_class,
                              uint16_t pid,
                              unsigned int param_data_length);

int RDMResponder_AddHeaderAndChecksum(const RDMHeader *incoming_header,
                                      RDMResponseType response_type,
                                      unsigned int message_length);

int RDMResponder_HandleDiscovery(const RDMHeader *incoming_header,
                                 const uint8_t *param_data);

int RDMResponder_BuildSetAck(const RDMHeader *incoming_header);

int RDMResponder_BuildNack(const RDMHeader *incoming_header,
                           RDMNackReason reason);

int RDMResponder_BuildAckTimer(const RDMHeader *incoming_header,
                               uint16_t delay);

int RDMResponder_BuildParamDescription(const RDMHeader *incoming_header,
                                       uint16_t param_id,
                                       const ParameterDescription *description);

int RDMResponder_DispatchPID(const RDMHeader *incoming_header,
                             const uint8_t *param_data);

int RDMResponder_Ioctl(ModelIoctl command, uint8_t *data,
                       unsigned int length);

// PID Handlers
// ----------------------------------------------------------------------------

int RDMResponder_GenericReturnString(const RDMHeader *incoming_header,
                                     const char *reply_string,
                                     unsigned int max_size);

int RDMResponder_GenericGetBool(const RDMHeader *incoming_header,
                                bool value);

int RDMResponder_GenericSetBool(const RDMHeader *incoming_header,
                                const uint8_t *param_data,
                                bool *value);

int RDMResponder_GenericGetUInt8(const RDMHeader *incoming_header,
                                 uint8_t value);

int RDMResponder_GenericSetUInt8(const RDMHeader *incoming_header,
                                 const uint8_t *param_data,
                                 uint8_t *value);

int RDMResponder_GenericGetUInt16(const RDMHeader *incoming_header,
                                  uint16_t value);

int RDMResponder_GenericSetUInt16(const RDMHeader *incoming_header,
                                  const uint8_t *param_data,
                                  uint16_t *value);

int RDMResponder_GenericGetUInt32(const RDMHeader *incoming_header,
                                  uint32_t value);

int RDMResponder_GenericSetUInt32(const RDMHeader *incoming_header,
                                  const uint8_t *param_data,
                                  uint32_t *value);

int RDMResponder_SetMute(const RDMHeader *incoming_header);

int RDMResponder_SetUnMute(const RDMHeader *incoming_header);

int RDMResponder_GetCommsStatus(const RDMHeader *incoming_header,
                                const uint8_t *param_data);

int RDMResponder_SetCommsStatus(const RDMHeader *incoming_header,
                                const uint8_t *param_data);

int RDMResponder_GetDeviceInfo(const RDMHeader *incoming_header,
                               const uint8_t *param_data);

int RDMResponder_GetSupportedParameters(const RDMHeader *incoming_header,
                                        const uint8_t *param_data);

int RDMResponder_GetProductDetailIds(const RDMHeader *incoming_header,
                                     const uint8_t *param_data);

int RDMResponder_GetDeviceModelDescription(const RDMHeader *incoming_header,
                                           const uint8_t *param_data);

int RDMResponder_GetManufacturerLabel(const RDMHeader *incoming_header,
                                      const uint8_t *param_data);

int RDMResponder_GetSoftwareVersionLabel(const RDMHeader *incoming_header,
                                         const uint8_t *param_data);

int RDMResponder_GetBootSoftwareVersion(const RDMHeader *incoming_header,
                                        const uint8_t *param_data);

int RDMResponder_GetBootSoftwareVersionLabel(const RDMHeader *incoming_header,
                                             const uint8_t *param_data);

int RDMResponder_GetDeviceLabel(const RDMHeader *incoming_header,
                                const uint8_t *param_data);

int RDMResponder_SetDeviceLabel(const RDMHeader *incoming_header,
                                const uint8_t *param_data);

int RDMResponder_GetDMXPersonality(const RDMHeader *incoming_header,
                                   const uint8_t *param_data);

int RDMResponder_SetDMXPersonality(const RDMHeader *incoming_header,
                                   const uint8_t *param_data);

int RDMResponder_GetDMXPersonalityDescription(const RDMHeader *incoming_header,
                                              const uint8_t *param_data);

int RDMResponder_GetDMXStartAddress(const RDMHeader *incoming_header,
                                    const uint8_t *param_data);

int RDMResponder_SetDMXStartAddress(const RDMHeader *incoming_header,
                                    const uint8_t *param_data);

int RDMResponder_GetSlotInfo(const RDMHeader *incoming_header,
                             const uint8_t *param_data);

int RDMResponder_GetSlotDescription(const RDMHeader *incoming_header,
                                    const uint8_t *param_data);

int RDMResponder_GetDefaultSlotValue(const RDMHeader *incoming_header,
                                     const uint8_t *param_data);


int RDMResponder_GetSensorDefinition(const RDMHeader *incoming_header,
                                     const uint8_t *param_data);

int RDMResponder_GetSensorValue(const RDMHeader *incoming_header,
                                const uint8_t *param_data);

int RDMResponder_SetSensorValue(const RDMHeader *incoming_header,
                                const uint8_t *param_data);

int RDMResponder_SetRecordSensor(const RDMHeader *incoming_header,
                                 const uint8_t *param_data);

int RDMResponder_GetIdentifyDevice(const RDMHeader *incoming_header,
                                   const uint8_t *param_data);

int RDMResponder_SetIdentifyDevice(const RDMHeader *incoming_header,
                                   const uint8_t *param_data);

#ifdef __cplusplus
}
#endif

#endif  // FIRMWARE_SRC_RDM_RESPONDER_H_