1

/**************************************************************************

     2

*

     3

* Copyright (C) 2005,2006,2009 Steve Karg <skarg@users.sourceforge.net>

     4

* Copyright (C) 2017 Mario de Sousa <msousa@fe.up.pt>

     5

*

     6

* Permission is hereby granted, free of charge, to any person obtaining

     7

* a copy of this software and associated documentation files (the

     8

* "Software"), to deal in the Software without restriction, including

     9

* without limitation the rights to use, copy, modify, merge, publish,

    10

* distribute, sublicense, and/or sell copies of the Software, and to

    11

* permit persons to whom the Software is furnished to do so, subject to

    12

* the following conditions:

    13

*

    14

* The above copyright notice and this permission notice shall be included

    15

* in all copies or substantial portions of the Software.

    16

*

    17

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

    18

* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

    19

* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

    20

* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

    21

* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

    22

* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

    23

* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

    24

*

    25

*********************************************************************/

    26

    27

/** Base "class" for handling all BACnet objects belonging

    28

 *  to a BACnet device, as well as Device-specific properties. */

    29

    30

#include <stdbool.h>

    31

#include <stdint.h>

    32

#include <string.h>     /* for memmove */

    33

#include <time.h>       /* for timezone, localtime */

    34

    35

#include "config_bacnet_for_beremiz_%(locstr)s.h"     /* the custom configuration for beremiz plugin */

    36

#include "bacdef.h"

    37

#include "bacdcode.h"

    38

#include "bacenum.h"

    39

#include "bacapp.h"

    40

#include "apdu.h"

    41

#include "wp.h" /* WriteProperty handling */

    42

#include "rp.h" /* ReadProperty handling */

    43

#include "dcc.h"        /* DeviceCommunicationControl handling */

    44

#include "version.h"

    45

#include "device_%(locstr)s.h"     /* me */

    46

#include "handlers.h"

    47

#include "datalink.h"

    48

#include "address.h"

    49

/* os specfic includes */

    50

#include "timer.h"

    51

/* include the device object */

    52

#include "device_%(locstr)s.h"

    53

#include "ai_%(locstr)s.h"

    54

#include "ao_%(locstr)s.h"

    55

#include "av_%(locstr)s.h"

    56

#include "bi_%(locstr)s.h"

    57

#include "bo_%(locstr)s.h"

    58

#include "bv_%(locstr)s.h"

    59

#include "msi_%(locstr)s.h"

    60

#include "mso_%(locstr)s.h"

    61

#include "msv_%(locstr)s.h"

    62

    63

    64

#if defined(__BORLANDC__) || defined(_WIN32)

    65

/* Not included in time.h as specified by The Open Group */

    66

/* Difference from UTC and local standard time */

    67

long int timezone;

    68

#endif

    69

    70

/* local forward (semi-private) and external prototypes */

    71

int Device_Read_Property_Local(

    72

    BACNET_READ_PROPERTY_DATA * rpdata);

    73

bool Device_Write_Property_Local(

    74

    BACNET_WRITE_PROPERTY_DATA * wp_data);

    75

extern int Routed_Device_Read_Property_Local(

    76

    BACNET_READ_PROPERTY_DATA * rpdata);

    77

extern bool Routed_Device_Write_Property_Local(

    78

    BACNET_WRITE_PROPERTY_DATA * wp_data);

    79

    80

/* may be overridden by outside table */

    81

static object_functions_t *Object_Table;

    82

    83

static object_functions_t My_Object_Table[] = {

    84

    {OBJECT_DEVICE,

    85

            NULL /* Init - don't init Device or it will recurse! */ ,

    86

            Device_Count,

    87

            Device_Index_To_Instance,

    88

            Device_Valid_Object_Instance_Number,

    89

            Device_Object_Name,

    90

            Device_Read_Property_Local,

    91

            Device_Write_Property_Local,

    92

            Device_Property_Lists,

    93

            DeviceGetRRInfo,

    94

            NULL /* Iterator */ ,

    95

            NULL /* Value_Lists */ ,

    96

            NULL /* COV */ ,

    97

            NULL /* COV Clear */ ,

    98

            NULL /* Intrinsic Reporting */ },

    99

    {OBJECT_ANALOG_INPUT,

   100

            Analog_Input_Init,

   101

            Analog_Input_Count,

   102

            Analog_Input_Index_To_Instance,

   103

            Analog_Input_Valid_Instance,

   104

            Analog_Input_Object_Name,

   105

            Analog_Input_Read_Property,

   106

            Analog_Input_Write_Property,

   107

            Analog_Input_Property_Lists,

   108

            NULL /* ReadRangeInfo */ ,

   109

            NULL /* Iterator */ ,

   110

            NULL /* Value_Lists */ ,

   111

            NULL /* COV */ ,

   112

            NULL /* COV Clear */ ,

   113

            NULL /* Intrinsic Reporting */ },

   114

    {OBJECT_ANALOG_OUTPUT,

   115

            Analog_Output_Init,

   116

            Analog_Output_Count,

   117

            Analog_Output_Index_To_Instance,

   118

            Analog_Output_Valid_Instance,

   119

            Analog_Output_Object_Name,

   120

            Analog_Output_Read_Property,

   121

            Analog_Output_Write_Property,

   122

            Analog_Output_Property_Lists,

   123

            NULL /* ReadRangeInfo */ ,

   124

            NULL /* Iterator */ ,

   125

            NULL /* Value_Lists */ ,

   126

            NULL /* COV */ ,

   127

            NULL /* COV Clear */ ,

   128

            NULL /* Intrinsic Reporting */ },

   129

    {OBJECT_ANALOG_VALUE,

   130

            Analog_Value_Init,

   131

            Analog_Value_Count,

   132

            Analog_Value_Index_To_Instance,

   133

            Analog_Value_Valid_Instance,

   134

            Analog_Value_Object_Name,

   135

            Analog_Value_Read_Property,

   136

            Analog_Value_Write_Property,

   137

            Analog_Value_Property_Lists,

   138

            NULL /* ReadRangeInfo */ ,

   139

            NULL /* Iterator */ ,

   140

            NULL /* Value_Lists */ ,

   141

            NULL /* COV */ ,

   142

            NULL /* COV Clear */ ,

   143

            NULL /* Intrinsic Reporting */ },

   144

    {OBJECT_BINARY_INPUT,

   145

            Binary_Input_Init,

   146

            Binary_Input_Count,

   147

            Binary_Input_Index_To_Instance,

   148

            Binary_Input_Valid_Instance,

   149

            Binary_Input_Object_Name,

   150

            Binary_Input_Read_Property,

   151

            Binary_Input_Write_Property,

   152

            Binary_Input_Property_Lists,

   153

            NULL /* ReadRangeInfo */ ,

   154

            NULL /* Iterator */ ,

   155

            NULL /* Value_Lists */ ,

   156

            NULL /* COV */ ,

   157

            NULL /* COV Clear */ ,

   158

            NULL /* Intrinsic Reporting */ },

   159

    {OBJECT_BINARY_OUTPUT,

   160

            Binary_Output_Init,

   161

            Binary_Output_Count,

   162

            Binary_Output_Index_To_Instance,

   163

            Binary_Output_Valid_Instance,

   164

            Binary_Output_Object_Name,

   165

            Binary_Output_Read_Property,

   166

            Binary_Output_Write_Property,

   167

            Binary_Output_Property_Lists,

   168

            NULL /* ReadRangeInfo */ ,

   169

            NULL /* Iterator */ ,

   170

            NULL /* Value_Lists */ ,

   171

            NULL /* COV */ ,

   172

            NULL /* COV Clear */ ,

   173

            NULL /* Intrinsic Reporting */ },

   174

    {OBJECT_BINARY_VALUE,

   175

            Binary_Value_Init,

   176

            Binary_Value_Count,

   177

            Binary_Value_Index_To_Instance,

   178

            Binary_Value_Valid_Instance,

   179

            Binary_Value_Object_Name,

   180

            Binary_Value_Read_Property,

   181

            Binary_Value_Write_Property,

   182

            Binary_Value_Property_Lists,

   183

            NULL /* ReadRangeInfo */ ,

   184

            NULL /* Iterator */ ,

   185

            NULL /* Value_Lists */ ,

   186

            NULL /* COV */ ,

   187

            NULL /* COV Clear */ ,

   188

            NULL /* Intrinsic Reporting */ },

   189

    {OBJECT_MULTI_STATE_INPUT,

   190

            Multistate_Input_Init,

   191

            Multistate_Input_Count,

   192

            Multistate_Input_Index_To_Instance,

   193

            Multistate_Input_Valid_Instance,

   194

            Multistate_Input_Object_Name,

   195

            Multistate_Input_Read_Property,

   196

            Multistate_Input_Write_Property,

   197

            Multistate_Input_Property_Lists,

   198

            NULL /* ReadRangeInfo */ ,

   199

            NULL /* Iterator */ ,

   200

            NULL /* Value_Lists */ ,

   201

            NULL /* COV */ ,

   202

            NULL /* COV Clear */ ,

   203

            NULL /* Intrinsic Reporting */ },

   204

    {OBJECT_MULTI_STATE_OUTPUT,

   205

            Multistate_Output_Init,

   206

            Multistate_Output_Count,

   207

            Multistate_Output_Index_To_Instance,

   208

            Multistate_Output_Valid_Instance,

   209

            Multistate_Output_Object_Name,

   210

            Multistate_Output_Read_Property,

   211

            Multistate_Output_Write_Property,

   212

            Multistate_Output_Property_Lists,

   213

            NULL /* ReadRangeInfo */ ,

   214

            NULL /* Iterator */ ,

   215

            NULL /* Value_Lists */ ,

   216

            NULL /* COV */ ,

   217

            NULL /* COV Clear */ ,

   218

            NULL /* Intrinsic Reporting */ },

   219

    {OBJECT_MULTI_STATE_VALUE,

   220

            Multistate_Value_Init,

   221

            Multistate_Value_Count,

   222

            Multistate_Value_Index_To_Instance,

   223

            Multistate_Value_Valid_Instance,

   224

            Multistate_Value_Object_Name,

   225

            Multistate_Value_Read_Property,

   226

            Multistate_Value_Write_Property,

   227

            Multistate_Value_Property_Lists,

   228

            NULL /* ReadRangeInfo */ ,

   229

            NULL /* Iterator */ ,

   230

            NULL /* Value_Lists */ ,

   231

            NULL /* COV */ ,

   232

            NULL /* COV Clear */ ,

   233

            NULL /* Intrinsic Reporting */ },

   234

    {MAX_BACNET_OBJECT_TYPE,

   235

            NULL /* Init */ ,

   236

            NULL /* Count */ ,

   237

            NULL /* Index_To_Instance */ ,

   238

            NULL /* Valid_Instance */ ,

   239

            NULL /* Object_Name */ ,

   240

            NULL /* Read_Property */ ,

   241

            NULL /* Write_Property */ ,

   242

            NULL /* Property_Lists */ ,

   243

            NULL /* ReadRangeInfo */ ,

   244

            NULL /* Iterator */ ,

   245

            NULL /* Value_Lists */ ,

   246

            NULL /* COV */ ,

   247

            NULL /* COV Clear */ ,

   248

        NULL /* Intrinsic Reporting */ }

   249

};

   250

   251

/** Glue function to let the Device object, when called by a handler,

   252

 * lookup which Object type needs to be invoked.

   253

 * param: Object_Type [in] The type of BACnet Object the handler wants to access.

   254

 * return: Pointer to the group of object helper functions that implement this

   255

 *         type of Object.

   256

 */

   257

static struct object_functions *Device_Objects_Find_Functions(

   258

    BACNET_OBJECT_TYPE Object_Type)

   259

{

   260

    struct object_functions *pObject = NULL;

   261

   262

    pObject = Object_Table;

   263

    while (pObject->Object_Type < MAX_BACNET_OBJECT_TYPE) {

   264

        /* handle each object type */

   265

        if (pObject->Object_Type == Object_Type) {

   266

            return (pObject);

   267

        }

   268

        pObject++;

   269

    }

   270

   271

    return (NULL);

   272

}

   273

   274

/** Try to find a rr_info_function helper function for the requested object type.

   275

 *

   276

 * param: object_type [in] The type of BACnet Object the handler wants to access.

   277

 * return: Pointer to the object helper function that implements the

   278

 *         ReadRangeInfo function, Object_RR_Info, for this type of Object on

   279

 *         success, else a NULL pointer if the type of Object isn't supported

   280

 *         or doesn't have a ReadRangeInfo function.

   281

 */

   282

rr_info_function Device_Objects_RR_Info(

   283

    BACNET_OBJECT_TYPE object_type)

   284

{

   285

    struct object_functions *pObject = NULL;

   286

   287

    pObject = Device_Objects_Find_Functions(object_type);

   288

    return (pObject != NULL ? pObject->Object_RR_Info : NULL);

   289

}

   290

   291

/** For a given object type, returns the special property list.

   292

 * This function is used for ReadPropertyMultiple calls which want

   293

 * just Required, just Optional, or All properties.

   294

 *

   295

 * param: object_type [in] The desired BACNET_OBJECT_TYPE whose properties

   296

 *            are to be listed.

   297

 * param: pPropertyList [out] Reference to the structure which will, on return,

   298

 *            list, separately, the Required, Optional, and Proprietary object

   299

 *            properties with their counts.

   300

 */

   301

void Device_Objects_Property_List(

   302

    BACNET_OBJECT_TYPE object_type,

   303

    struct special_property_list_t *pPropertyList)

   304

{

   305

    struct object_functions *pObject = NULL;

   306

   307

    pPropertyList->Required.pList = NULL;

   308

    pPropertyList->Optional.pList = NULL;

   309

    pPropertyList->Proprietary.pList = NULL;

   310

   311

    /* If we can find an entry for the required object type

   312

     * and there is an Object_List_RPM fn ptr then call it

   313

     * to populate the pointers to the individual list counters.

   314

     */

   315

   316

    pObject = Device_Objects_Find_Functions(object_type);

   317

    if ((pObject != NULL) && (pObject->Object_RPM_List != NULL)) {

   318

        pObject->Object_RPM_List(&pPropertyList->Required.pList,

   319

            &pPropertyList->Optional.pList, &pPropertyList->Proprietary.pList);

   320

    }

   321

   322

    /* Fetch the counts if available otherwise zero them */

   323

    pPropertyList->Required.count =

   324

        pPropertyList->Required.pList ==

   325

        NULL ? 0 : property_list_count(pPropertyList->Required.pList);

   326

   327

    pPropertyList->Optional.count =

   328

        pPropertyList->Optional.pList ==

   329

        NULL ? 0 : property_list_count(pPropertyList->Optional.pList);

   330

   331

    pPropertyList->Proprietary.count =

   332

        pPropertyList->Proprietary.pList ==

   333

        NULL ? 0 : property_list_count(pPropertyList->Proprietary.pList);

   334

   335

    return;

   336

}

   337

   338

/** Commands a Device re-initialization, to a given state.

   339

 * The request's password must match for the operation to succeed.

   340

 * This implementation provides a framework, but doesn't

   341

 * actually *DO* anything.

   342

 * @note You could use a mix of states and passwords to multiple outcomes.

   343

 * @note You probably want to restart *after* the simple ack has been sent

   344

 *       from the return handler, so just set a local flag here.

   345

 *

   346

 * param: rd_data [in,out] The information from the RD request.

   347

 *                         On failure, the error class and code will be set.

   348

 * return: True if succeeds (password is correct), else False.

   349

 */

   350

bool Device_Reinitialize(

   351

    BACNET_REINITIALIZE_DEVICE_DATA * rd_data)

   352

{

   353

    bool status = false;

   354

   355

    if (characterstring_ansi_same(&rd_data->password, "Jesus")) {

   356

        switch (rd_data->state) {

   357

            case BACNET_REINIT_COLDSTART:

   358

            case BACNET_REINIT_WARMSTART:

   359

                dcc_set_status_duration(COMMUNICATION_ENABLE, 0);

   360

                break;

   361

            case BACNET_REINIT_STARTBACKUP:

   362

                break;

   363

            case BACNET_REINIT_ENDBACKUP:

   364

                break;

   365

            case BACNET_REINIT_STARTRESTORE:

   366

                break;

   367

            case BACNET_REINIT_ENDRESTORE:

   368

                break;

   369

            case BACNET_REINIT_ABORTRESTORE:

   370

                break;

   371

            default:

   372

                break;

   373

        }

   374

        /* Note: you could use a mix of state

   375

           and password to multiple things */

   376

        /* note: you probably want to restart *after* the

   377

           simple ack has been sent from the return handler

   378

           so just set a flag from here */

   379

        status = true;

   380

    } else {

   381

        rd_data->error_class = ERROR_CLASS_SECURITY;

   382

        rd_data->error_code = ERROR_CODE_PASSWORD_FAILURE;

   383

    }

   384

   385

    return status;

   386

}

   387

   388

/* These three arrays are used by the ReadPropertyMultiple handler,

   389

 * as well as to initialize the XXX_Property_List used by the 

   390

 * Property List (PROP_PROPERTY_LIST) property.

   391

 */

   392

static const int Device_Properties_Required[] = {

   393

 /* (1) Currently Supported                  */

   394

 /* (2) Required by standard ASHRAE 135-2016 */

   395

                                           /*(1)(2)      */

   396

    PROP_OBJECT_IDENTIFIER,                /* W  R ( 75) */

   397

    PROP_OBJECT_NAME,                      /* W  R ( 77) */

   398

    PROP_OBJECT_TYPE,                      /* R  R ( 79) */

   399

    PROP_SYSTEM_STATUS,                    /* R  R (112) */

   400

    PROP_VENDOR_NAME,                      /* R  R (121) */

   401

    PROP_VENDOR_IDENTIFIER,                /* W  R (120) */

   402

    PROP_MODEL_NAME,                       /* W  R ( 70) */

   403

    PROP_FIRMWARE_REVISION,                /* R  R ( 44) */

   404

    PROP_APPLICATION_SOFTWARE_VERSION,     /* R  R ( 12) */

   405

    PROP_PROTOCOL_VERSION,                 /* R  R ( 98) */

   406

    PROP_PROTOCOL_REVISION,                /* R  R (139) */

   407

    PROP_PROTOCOL_SERVICES_SUPPORTED,      /* R  R ( 97) */

   408

    PROP_PROTOCOL_OBJECT_TYPES_SUPPORTED,  /* R  R ( 96) */

   409

    PROP_OBJECT_LIST,                      /* R  R ( 76) */

   410

    PROP_MAX_APDU_LENGTH_ACCEPTED,         /* R  R ( 62) */

   411

    PROP_SEGMENTATION_SUPPORTED,           /* R  R (107) */

   412

    PROP_APDU_TIMEOUT,                     /* W  R ( 11) */

   413

    PROP_NUMBER_OF_APDU_RETRIES,           /* W  R ( 73) */

   414

    PROP_DEVICE_ADDRESS_BINDING,           /* R  R ( 30) */

   415

    PROP_DATABASE_REVISION,                /* R  R (155) */

   416

//  PROP_PROPERTY_LIST,                    /* R  R (371) */

   417

    -1

   418

};

   419

   420

static const int Device_Properties_Optional[] = {

   421

    PROP_DESCRIPTION,                      /* W  O ( 28) */

   422

    PROP_LOCAL_TIME,                       /* R  O ( 57) */

   423

    PROP_UTC_OFFSET,                       /* R  O (119) */

   424

    PROP_LOCAL_DATE,                       /* R  O ( 56) */

   425

    PROP_DAYLIGHT_SAVINGS_STATUS,          /* R  O ( 24) */

   426

    PROP_LOCATION,                         /* W  O ( 58) */

   427

    -1

   428

};

   429

   430

static const int Device_Properties_Proprietary[] = {

   431

    -1

   432

};

   433

   434

/* This array stores the PROPERTY_LIST which may be read by clients.

   435

 * End of list is marked by following the last element with the value '-1'

   436

 * 

   437

 * It is initialized by Binary_Value_Init() based off the values

   438

 * stored in Binary_Value_Properties_Required 

   439

 *           Binary_Value_Properties_Optional

   440

 *           Binary_Value_Properties_Proprietary

   441

 */

   442

/* TODO: Allocate memory for this array with malloc() at startup */

   443

static int Device_Properties_List[64];

   444

   445

   446

void Device_Property_Lists(

   447

    const int **pRequired,

   448

    const int **pOptional,

   449

    const int **pProprietary)

   450

{

   451

    if (pRequired)

   452

        *pRequired = Device_Properties_Required;

   453

    if (pOptional)

   454

        *pOptional = Device_Properties_Optional;

   455

    if (pProprietary)

   456

        *pProprietary = Device_Properties_Proprietary;

   457

   458

    return;

   459

}

   460

   461

   462

static BACNET_DEVICE_STATUS System_Status = STATUS_OPERATIONAL;

   463

   464

static BACNET_CHARACTER_STRING My_Object_Name;

   465

static uint32_t Object_Instance_Number                             = 260001;

   466

static uint16_t Vendor_Identifier                                  = BACNET_VENDOR_ID;

   467

static char    *Vendor_Name                                        = BACNET_VENDOR_NAME;

   468

static char    *Firmware_Revision                                  = BACNET_FIRMWARE_REVISION;

   469

static char     Model_Name                  [MAX_DEV_MOD_LEN  + 1] = BACNET_DEVICE_MODEL_NAME;

   470

static char     Application_Software_Version[MAX_DEV_VER_LEN  + 1] = BACNET_DEVICE_APPSOFT_VER;

   471

static char     Location                    [MAX_DEV_LOC_LEN  + 1] = BACNET_DEVICE_LOCATION;

   472

static char     Description                 [MAX_DEV_DESC_LEN + 1] = BACNET_DEVICE_DESCRIPTION;

   473

/* static uint8_t Protocol_Version = 1; - constant, not settable */

   474

/* static uint8_t Protocol_Revision = 4; - constant, not settable */

   475

/* Protocol_Services_Supported - dynamically generated */

   476

/* Protocol_Object_Types_Supported - in RP encoding */

   477

/* Object_List - dynamically generated */

   478

/* static BACNET_SEGMENTATION Segmentation_Supported = SEGMENTATION_NONE; */

   479

/* static uint8_t Max_Segments_Accepted = 0; */

   480

/* VT_Classes_Supported */

   481

/* Active_VT_Sessions */

   482

static BACNET_TIME Local_Time;  /* rely on OS, if there is one */

   483

static BACNET_DATE Local_Date;  /* rely on OS, if there is one */

   484

/* NOTE: BACnet UTC Offset is inverse of common practice.

   485

   If your UTC offset is -5hours of GMT,

   486

   then BACnet UTC offset is +5hours.

   487

   BACnet UTC offset is expressed in minutes. */

   488

static int32_t UTC_Offset = 5 * 60;

   489

static bool Daylight_Savings_Status = false;    /* rely on OS */

   490

/* List_Of_Session_Keys */

   491

/* Time_Synchronization_Recipients */

   492

/* Max_Master - rely on MS/TP subsystem, if there is one */

   493

/* Max_Info_Frames - rely on MS/TP subsystem, if there is one */

   494

/* Device_Address_Binding - required, but relies on binding cache */

   495

static uint32_t Database_Revision = 0;

   496

/* Configuration_Files */

   497

/* Last_Restore_Time */

   498

/* Backup_Failure_Timeout */

   499

/* Active_COV_Subscriptions */

   500

/* Slave_Proxy_Enable */

   501

/* Manual_Slave_Address_Binding */

   502

/* Auto_Slave_Discovery */

   503

/* Slave_Address_Binding */

   504

/* Profile_Name */

   505

   506

unsigned Device_Count(

   507

    void)

   508

{

   509

    return 1;

   510

}

   511

   512

uint32_t Device_Index_To_Instance(

   513

    unsigned index)

   514

{

   515

    index = index;

   516

    return Object_Instance_Number;

   517

}

   518

   519

/* methods to manipulate the data */

   520

   521

/** Return the Object Instance number for our (single) Device Object.

   522

 * This is a key function, widely invoked by the handler code, since

   523

 * it provides "our" (ie, local) address.

   524

 * return: The Instance number used in the BACNET_OBJECT_ID for the Device.

   525

 */

   526

uint32_t Device_Object_Instance_Number(

   527

    void)

   528

{

   529