mirror/bacnet-stack
1
0
Fork 0
mirror of https://github.com/stargieg/bacnet-stack synced 2025-10-26 23:35:52 +08:00
Code Issues Releases Wiki Activity

add uci init loop for bi

Browse Source
This commit is contained in:
Patrick Grimm
2014-02-23 01:54:36 +01:00
parent 4bba8ea862
commit 7815f3cc28
3 changed files with 249 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files

350
demo/object/bi.c
View File

@@ -31,22 +31,33 @@
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <stdlib.h>
#include "bacdef.h" #include "bacdef.h"
#include "bacdcode.h" #include "bacdcode.h"
#include "bacenum.h" #include "bacenum.h"
#include "bacapp.h" #include "bacapp.h"
#include "bactext.h" #include "bactext.h"
#include "cov.h"
#include "config.h" /* the custom stuff */ #include "config.h" /* the custom stuff */
#include "device.h" #include "device.h"
#include "handlers.h" #include "handlers.h"
#include "bi.h" #include "bi.h"
#include "ucix.h" #include "ucix.h"
/* number of demo objects */
#ifndef MAX_BINARY_INPUTS #ifndef MAX_BINARY_INPUTS
#define MAX_BINARY_INPUTS 512 #define MAX_BINARY_INPUTS 65535
#endif #endif
unsigned max_binary_inputs_int = 0;
/* When all the priorities are level null, the present value returns */
/* the Relinquish Default value */
#define BINARY_RELINQUISH_DEFAULT 0
/* we choose to have a NULL level in our system represented by */
/* a particular value. When the priorities are not in use, they */
/* will be relinquished (i.e. set to the NULL level). */
#define BINARY_LEVEL_NULL 255
BINARY_INPUT_DESCR BI_Descr[MAX_BINARY_INPUTS]; BINARY_INPUT_DESCR BI_Descr[MAX_BINARY_INPUTS];
@@ -105,6 +116,26 @@ void Binary_Input_Property_Lists(
return; return;
} }
void Binary_Input_Load_UCI_List(const char *sec_idx,
struct bi_inst_itr_ctx *itr)
{
bi_inst_tuple_t *t = malloc(sizeof(bi_inst_tuple_t));
bool disable;
disable = ucix_get_option_int(itr->ctx, itr->section, sec_idx,
"disable", 0);
if (strcmp(sec_idx,"default") == 0)
return;
if (disable)
return;
if( (t = (bi_inst_tuple_t *)malloc(sizeof(bi_inst_tuple_t))) != NULL ) {
strncpy(t->idx, sec_idx, sizeof(t->idx));
t->next = itr->list;
itr->list = t;
}
return;
}
/* /*
* Things to do when starting up the stack for Binary Input. * Things to do when starting up the stack for Binary Input.
* Should be called whenever we reset the device or power it up * Should be called whenever we reset the device or power it up
@@ -139,46 +170,62 @@ void Binary_Input_Init(
int ucialarm_value; int ucialarm_value;
int ucipolarity_default; int ucipolarity_default;
int ucipolarity; int ucipolarity;
fprintf(stderr, "Binary_Input_Init\n"); const char *sec = "bacnet_bi";
char *section;
char *type;
struct bi_inst_itr_ctx itr_m;
section = "bacnet_bi";
#if PRINT_ENABLED
fprintf(stderr, "Binary_Input_Init\n");
#endif
if (!initialized) { if (!initialized) {
initialized = true; initialized = true;
ctx = ucix_init("bacnet_bi"); ctx = ucix_init("bacnet_bi");
#if PRINT_ENABLED
if(!ctx) if(!ctx)
fprintf(stderr, "Failed to load config file bacnet_bi\n"); fprintf(stderr, "Failed to load config file bacnet_bi\n");
#endif
ucidescription_default = ucix_get_option(ctx, "bacnet_bi", "default", type = "bi";
"description"); bi_inst_tuple_t *cur = malloc(sizeof (bi_inst_tuple_t));
uciinactive_text_default = ucix_get_option(ctx, "bacnet_bi", "default", itr_m.list = NULL;
"inactive"); itr_m.section = section;
uciactive_text_default = ucix_get_option(ctx, "bacnet_bi", "default", itr_m.ctx = ctx;
"active"); ucix_for_each_section_type(ctx, section, type,
ucinc_default = ucix_get_option_int(ctx, "bacnet_bi", "default", (void *)Binary_Input_Load_UCI_List, &itr_m);
"nc", -1);
ucievent_default = ucix_get_option_int(ctx, "bacnet_bi", "default",
"event", -1);
ucitime_delay_default = ucix_get_option_int(ctx, "bacnet_bi", "default",
"time_delay", -1);
ucialarm_value_default = ucix_get_option_int(ctx, "bacnet_bi", "default",
"alarm_value", -1);
ucipolarity_default = ucix_get_option_int(ctx, "bacnet_bi", "default",
"polarity", 0);
/* initialize all the values */ ucidescription_default = ucix_get_option(ctx, sec, "default",
for (i = 0; i < MAX_BINARY_INPUTS; i++) { "description");
memset(&BI_Descr[i], 0x00, sizeof(BINARY_INPUT_DESCR)); uciinactive_text_default = ucix_get_option(ctx, sec, "default",
sprintf(idx_cc,"%d",i); "inactive");
uciactive_text_default = ucix_get_option(ctx, sec, "default",
"active");
ucinc_default = ucix_get_option_int(ctx, sec, "default",
"nc", -1);
ucievent_default = ucix_get_option_int(ctx, sec, "default",
"event", -1);
ucitime_delay_default = ucix_get_option_int(ctx, sec, "default",
"time_delay", -1);
ucialarm_value_default = ucix_get_option_int(ctx, sec, "default",
"alarm_value", -1);
ucipolarity_default = ucix_get_option_int(ctx, sec, "default",
"polarity", 0);
i = 0;
for( cur = itr_m.list; cur; cur = cur->next ) {
strncpy(idx_cc, cur->idx, sizeof(idx_cc));
idx_c = idx_cc; idx_c = idx_cc;
uciname = ucix_get_option(ctx, "bacnet_bi", idx_c, "name"); uciname = ucix_get_option(ctx, "bacnet_bi", idx_c, "name");
ucidisable = ucix_get_option_int(ctx, "bacnet_bi", idx_c, ucidisable = ucix_get_option_int(ctx, "bacnet_bi", idx_c,
"disable", 0); "disable", 0);
if ((uciname != 0) && (ucidisable == 0)) { if ((uciname != 0) && (ucidisable == 0)) {
BI_Descr[i].Disable=false; memset(&BI_Descr[i], 0x00, sizeof(BINARY_INPUT_DESCR));
/* initialize all the priority arrays to NULL */ /* initialize all the priority arrays to NULL */
for (j = 0; j < BACNET_MAX_PRIORITY; j++) { for (j = 0; j < BACNET_MAX_PRIORITY; j++) {
BI_Descr[i].Priority_Array[j] = BINARY_NULL; BI_Descr[i].Priority_Array[j] = BINARY_LEVEL_NULL;
} }
max_binary_inputs = i+1; BI_Descr[i].Instance=atoi(idx_cc);
BI_Descr[i].Disable=false;
sprintf(name, "%s", uciname); sprintf(name, "%s", uciname);
ucix_string_copy(BI_Descr[i].Object_Name, ucix_string_copy(BI_Descr[i].Object_Name,
sizeof(BI_Descr[i].Object_Name), name); sizeof(BI_Descr[i].Object_Name), name);
@@ -265,15 +312,16 @@ void Binary_Input_Init(
handler_get_alarm_summary_set(OBJECT_BINARY_INPUT, handler_get_alarm_summary_set(OBJECT_BINARY_INPUT,
Binary_Input_Alarm_Summary); Binary_Input_Alarm_Summary);
#endif #endif
} else { i++;
BI_Descr[i].Disable=true; max_binary_inputs_int = i;
} }
} }
fprintf(stderr, "max_binary_inputs %i\n", max_binary_inputs); #if PRINT_ENABLED
fprintf(stderr, "max_binary_inputs %i\n", max_binary_inputs_int);
#endif
if(ctx) if(ctx)
ucix_cleanup(ctx); ucix_cleanup(ctx);
} }
return; return;
} }
@@ -283,13 +331,16 @@ void Binary_Input_Init(
unsigned Binary_Input_Instance_To_Index( unsigned Binary_Input_Instance_To_Index(
uint32_t object_instance) uint32_t object_instance)
{ {
unsigned index = max_binary_inputs; BINARY_INPUT_DESCR *CurrentBI;
int index,i;
if (object_instance < max_binary_inputs) { index = max_binary_inputs_int;
index = object_instance; for (i = 0; i < index; i++) {
CurrentBI = &BI_Descr[i];
if (CurrentBI->Instance == object_instance) {
return i;
}
} }
return MAX_BINARY_INPUTS;
return index;
} }
/* we simply have 0-n object instances. Yours might be */ /* we simply have 0-n object instances. Yours might be */
@@ -299,16 +350,10 @@ uint32_t Binary_Input_Index_To_Instance(
unsigned index) unsigned index)
{ {
BINARY_INPUT_DESCR *CurrentBI; BINARY_INPUT_DESCR *CurrentBI;
if (index < max_binary_inputs) { uint32_t instance;
CurrentBI = &BI_Descr[index]; CurrentBI = &BI_Descr[index];
if (CurrentBI->Disable == false) { instance = CurrentBI->Instance;
return index; return instance;
} else {
return false;
}
} else {
return false;
}
} }
/* we simply have 0-n object instances. Yours might be */ /* we simply have 0-n object instances. Yours might be */
@@ -316,7 +361,7 @@ uint32_t Binary_Input_Index_To_Instance(
unsigned Binary_Input_Count( unsigned Binary_Input_Count(
void) void)
{ {
return max_binary_inputs; return max_binary_inputs_int;
} }
/* we simply have 0-n object instances. Yours might be */ /* we simply have 0-n object instances. Yours might be */
@@ -328,14 +373,16 @@ bool Binary_Input_Valid_Instance(
BINARY_INPUT_DESCR *CurrentBI; BINARY_INPUT_DESCR *CurrentBI;
unsigned index = 0; /* offset from instance lookup */ unsigned index = 0; /* offset from instance lookup */
index = Binary_Input_Instance_To_Index(object_instance); index = Binary_Input_Instance_To_Index(object_instance);
if (index < max_binary_inputs) { if (index == MAX_BINARY_INPUTS) {
CurrentBI = &BI_Descr[index]; #if PRINT_ENABLED
if (CurrentBI->Disable == false) { fprintf(stderr, "Binary_Input_Valid_Instance %i invalid index %i max %i\n",
return true; object_instance,index,max_binary_inputs_int);
} else { #endif
return false; return false;
}
} }
CurrentBI = &BI_Descr[index];
if (CurrentBI->Disable == false)
return true;
return false; return false;
} }
@@ -344,18 +391,18 @@ BACNET_BINARY_PV Binary_Input_Present_Value(
uint32_t object_instance) uint32_t object_instance)
{ {
BINARY_INPUT_DESCR *CurrentBI; BINARY_INPUT_DESCR *CurrentBI;
BACNET_BINARY_PV value = BINARY_INACTIVE; BACNET_BINARY_PV value = BINARY_RELINQUISH_DEFAULT;
unsigned index = 0; unsigned index = 0;
unsigned i = 0; unsigned i = 0;
index = Binary_Input_Instance_To_Index(object_instance); if (Binary_Input_Valid_Instance(object_instance)) {
if (index < max_binary_inputs) { index = Binary_Input_Instance_To_Index(object_instance);
CurrentBI = &BI_Descr[index]; CurrentBI = &BI_Descr[index];
/* When all the priorities are level null, the present value returns */ /* When all the priorities are level null, the present value returns */
/* the Relinquish Default value */ /* the Relinquish Default value */
value = CurrentBI->Relinquish_Default; value = CurrentBI->Relinquish_Default;
for (i = 0; i < BACNET_MAX_PRIORITY; i++) { for (i = 0; i < BACNET_MAX_PRIORITY; i++) {
if (CurrentBI->Priority_Array[i] != BINARY_NULL) { if (CurrentBI->Priority_Array[i] != BINARY_LEVEL_NULL) {
value = CurrentBI->Priority_Array[i]; value = CurrentBI->Priority_Array[i];
break; break;
} }
@@ -365,6 +412,30 @@ BACNET_BINARY_PV Binary_Input_Present_Value(
return value; return value;
} }
unsigned Binary_Input_Present_Value_Priority(
uint32_t object_instance)
{
BINARY_INPUT_DESCR *CurrentBI;
unsigned index = 0; /* instance to index conversion */
unsigned i = 0; /* loop counter */
unsigned priority = 0; /* return value */
if (Binary_Input_Valid_Instance(object_instance)) {
index = Binary_Input_Instance_To_Index(object_instance);
CurrentBI = &BI_Descr[index];
for (i = 0; i < BACNET_MAX_PRIORITY; i++) {
if (CurrentBI->Priority_Array[priority] != BINARY_LEVEL_NULL) {
priority = i + 1;
break;
}
}
}
return priority;
}
bool Binary_Input_Out_Of_Service( bool Binary_Input_Out_Of_Service(
uint32_t object_instance) uint32_t object_instance)
{ {
@@ -372,8 +443,8 @@ bool Binary_Input_Out_Of_Service(
unsigned index = 0; /* offset from instance lookup */ unsigned index = 0; /* offset from instance lookup */
bool value = false; bool value = false;
index = Binary_Input_Instance_To_Index(object_instance); if (Binary_Input_Valid_Instance(object_instance)) {
if (index < max_binary_inputs) { index = Binary_Input_Instance_To_Index(object_instance);
CurrentBI = &BI_Descr[index]; CurrentBI = &BI_Descr[index];
value = CurrentBI->Out_Of_Service; value = CurrentBI->Out_Of_Service;
} }
@@ -388,8 +459,8 @@ void Binary_Input_Out_Of_Service_Set(
BINARY_INPUT_DESCR *CurrentBI; BINARY_INPUT_DESCR *CurrentBI;
unsigned index = 0; unsigned index = 0;
index = Binary_Input_Instance_To_Index(object_instance); if (Binary_Input_Valid_Instance(object_instance)) {
if (index < max_binary_inputs) { index = Binary_Input_Instance_To_Index(object_instance);
CurrentBI = &BI_Descr[index]; CurrentBI = &BI_Descr[index];
if (CurrentBI->Out_Of_Service != value) { if (CurrentBI->Out_Of_Service != value) {
CurrentBI->Change_Of_Value = true; CurrentBI->Change_Of_Value = true;
@@ -407,8 +478,8 @@ uint8_t Binary_Input_Reliability(
unsigned index = 0; /* offset from instance lookup */ unsigned index = 0; /* offset from instance lookup */
uint8_t value = 0; uint8_t value = 0;
index = Binary_Input_Instance_To_Index(object_instance); if (Binary_Input_Valid_Instance(object_instance)) {
if (index < max_binary_inputs) { index = Binary_Input_Instance_To_Index(object_instance);
CurrentBI = &BI_Descr[index]; CurrentBI = &BI_Descr[index];
value = CurrentBI->Reliability; value = CurrentBI->Reliability;
} }
@@ -423,8 +494,8 @@ void Binary_Input_Reliability_Set(
BINARY_INPUT_DESCR *CurrentBI; BINARY_INPUT_DESCR *CurrentBI;
unsigned index = 0; unsigned index = 0;
index = Binary_Input_Instance_To_Index(object_instance); if (Binary_Input_Valid_Instance(object_instance)) {
if (index < max_binary_inputs) { index = Binary_Input_Instance_To_Index(object_instance);
CurrentBI = &BI_Descr[index]; CurrentBI = &BI_Descr[index];
CurrentBI->Reliability = value; CurrentBI->Reliability = value;
} }
@@ -439,8 +510,8 @@ static char *Binary_Input_Description(
unsigned index = 0; /* offset from instance lookup */ unsigned index = 0; /* offset from instance lookup */
char *pName = NULL; /* return value */ char *pName = NULL; /* return value */
index = Binary_Input_Instance_To_Index(object_instance); if (Binary_Input_Valid_Instance(object_instance)) {
if (index < max_binary_inputs) { index = Binary_Input_Instance_To_Index(object_instance);
CurrentBI = &BI_Descr[index]; CurrentBI = &BI_Descr[index];
pName = CurrentBI->Object_Description; pName = CurrentBI->Object_Description;
} }
@@ -457,8 +528,8 @@ bool Binary_Input_Description_Set(
size_t i = 0; /* loop counter */ size_t i = 0; /* loop counter */
bool status = false; /* return value */ bool status = false; /* return value */
index = Binary_Input_Instance_To_Index(object_instance); if (Binary_Input_Valid_Instance(object_instance)) {
if (index < max_binary_inputs) { index = Binary_Input_Instance_To_Index(object_instance);
CurrentBI = &BI_Descr[index]; CurrentBI = &BI_Descr[index];
status = true; status = true;
if (new_name) { if (new_name) {
@@ -492,8 +563,8 @@ static bool Binary_Input_Description_Write(
const char *idx_c; const char *idx_c;
char idx_cc[64]; char idx_cc[64];
index = Binary_Input_Instance_To_Index(object_instance); if (Binary_Input_Valid_Instance(object_instance)) {
if (index < max_binary_inputs) { index = Binary_Input_Instance_To_Index(object_instance);
CurrentBI = &BI_Descr[index]; CurrentBI = &BI_Descr[index];
length = characterstring_length(char_string); length = characterstring_length(char_string);
if (length <= sizeof(CurrentBI->Object_Description)) { if (length <= sizeof(CurrentBI->Object_Description)) {
@@ -512,9 +583,11 @@ static bool Binary_Input_Description_Write(
if(ctx) { if(ctx) {
ucix_add_option(ctx, "bacnet_bi", idx_c, ucix_add_option(ctx, "bacnet_bi", idx_c,
"description", char_string->value); "description", char_string->value);
#if PRINT_ENABLED
} else { } else {
fprintf(stderr, fprintf(stderr,
"Failed to open config file bacnet_bi\n"); "Failed to open config file bacnet_bi\n");
#endif
} }
} }
} else { } else {
@@ -539,9 +612,8 @@ bool Binary_Input_Object_Name(
unsigned index = 0; /* offset from instance lookup */ unsigned index = 0; /* offset from instance lookup */
bool status = false; bool status = false;
index = Binary_Input_Instance_To_Index(object_instance); if (Binary_Input_Valid_Instance(object_instance)) {
index = Binary_Input_Instance_To_Index(object_instance);
if (index < max_binary_inputs) {
CurrentBI = &BI_Descr[index]; CurrentBI = &BI_Descr[index];
status = characterstring_init_ansi(object_name, CurrentBI->Object_Name); status = characterstring_init_ansi(object_name, CurrentBI->Object_Name);
} }
@@ -559,8 +631,8 @@ bool Binary_Input_Name_Set(
size_t i = 0; /* loop counter */ size_t i = 0; /* loop counter */
bool status = false; /* return value */ bool status = false; /* return value */
index = Binary_Input_Instance_To_Index(object_instance); if (Binary_Input_Valid_Instance(object_instance)) {
if (index < max_binary_inputs) { index = Binary_Input_Instance_To_Index(object_instance);
CurrentBI = &BI_Descr[index]; CurrentBI = &BI_Descr[index];
status = true; status = true;
/* FIXME: check to see if there is a matching name */ /* FIXME: check to see if there is a matching name */
@@ -595,8 +667,8 @@ static bool Binary_Input_Object_Name_Write(
const char *idx_c; const char *idx_c;
char idx_cc[64]; char idx_cc[64];
index = Binary_Input_Instance_To_Index(object_instance); if (Binary_Input_Valid_Instance(object_instance)) {
if (index < max_binary_inputs) { index = Binary_Input_Instance_To_Index(object_instance);
CurrentBI = &BI_Descr[index]; CurrentBI = &BI_Descr[index];
length = characterstring_length(char_string); length = characterstring_length(char_string);
if (length <= sizeof(CurrentBI->Object_Name)) { if (length <= sizeof(CurrentBI->Object_Name)) {
@@ -638,10 +710,10 @@ bool Binary_Input_Change_Of_Value(
{ {
BINARY_INPUT_DESCR *CurrentBI; BINARY_INPUT_DESCR *CurrentBI;
bool status = false; bool status = false;
unsigned index; unsigned index = 0;
index = Binary_Input_Instance_To_Index(object_instance); if (Binary_Input_Valid_Instance(object_instance)) {
if (index < max_binary_inputs) { index = Binary_Input_Instance_To_Index(object_instance);
CurrentBI = &BI_Descr[index]; CurrentBI = &BI_Descr[index];
status = CurrentBI->Change_Of_Value; status = CurrentBI->Change_Of_Value;
} }
@@ -653,10 +725,10 @@ void Binary_Input_Change_Of_Value_Clear(
uint32_t object_instance) uint32_t object_instance)
{ {
BINARY_INPUT_DESCR *CurrentBI; BINARY_INPUT_DESCR *CurrentBI;
unsigned index; unsigned index = 0;
index = Binary_Input_Instance_To_Index(object_instance); if (Binary_Input_Valid_Instance(object_instance)) {
if (index < max_binary_inputs) { index = Binary_Input_Instance_To_Index(object_instance);
CurrentBI = &BI_Descr[index]; CurrentBI = &BI_Descr[index];
CurrentBI->Change_Of_Value = false; CurrentBI->Change_Of_Value = false;
} }
@@ -716,10 +788,10 @@ bool Binary_Input_Present_Value_Set(
unsigned index = 0; /* offset from instance lookup */ unsigned index = 0; /* offset from instance lookup */
bool status = false; bool status = false;
if (value > 1) if (value > 1)
value = BINARY_NULL; value = BINARY_LEVEL_NULL;
index = Binary_Input_Instance_To_Index(object_instance); if (Binary_Input_Valid_Instance(object_instance)) {
if (index < max_binary_inputs) { index = Binary_Input_Instance_To_Index(object_instance);
CurrentBI = &BI_Descr[index]; CurrentBI = &BI_Descr[index];
CurrentBI->Present_Value = (uint8_t) value; CurrentBI->Present_Value = (uint8_t) value;
CurrentBI->Priority_Array[priority - 1] = (uint8_t) value; CurrentBI->Priority_Array[priority - 1] = (uint8_t) value;
@@ -736,8 +808,8 @@ BACNET_POLARITY Binary_Input_Polarity(
BACNET_POLARITY polarity = POLARITY_NORMAL; BACNET_POLARITY polarity = POLARITY_NORMAL;
index = Binary_Input_Instance_To_Index(object_instance); if (Binary_Input_Valid_Instance(object_instance)) {
if (object_instance < max_binary_inputs) { index = Binary_Input_Instance_To_Index(object_instance);
CurrentBI = &BI_Descr[index]; CurrentBI = &BI_Descr[index];
polarity = CurrentBI->Polarity; polarity = CurrentBI->Polarity;
} }
@@ -755,8 +827,8 @@ bool Binary_Input_Polarity_Set(
const char *idx_c; const char *idx_c;
char idx_cc[64]; char idx_cc[64];
index = Binary_Input_Instance_To_Index(object_instance); if (Binary_Input_Valid_Instance(object_instance)) {
if (object_instance < max_binary_inputs) { index = Binary_Input_Instance_To_Index(object_instance);
CurrentBI = &BI_Descr[index]; CurrentBI = &BI_Descr[index];
CurrentBI->Polarity=polarity; CurrentBI->Polarity=polarity;
sprintf(idx_cc,"%d",index); sprintf(idx_cc,"%d",index);
@@ -787,8 +859,8 @@ static bool Binary_Input_Active_Text_Write(
const char *idx_c; const char *idx_c;
char idx_cc[64]; char idx_cc[64];
index = Binary_Input_Instance_To_Index(object_instance); if (Binary_Input_Valid_Instance(object_instance)) {
if (index < max_binary_inputs) { index = Binary_Input_Instance_To_Index(object_instance);
CurrentBI = &BI_Descr[index]; CurrentBI = &BI_Descr[index];
length = characterstring_length(char_string); length = characterstring_length(char_string);
if (length <= sizeof(CurrentBI->Active_Text)) { if (length <= sizeof(CurrentBI->Active_Text)) {
@@ -837,8 +909,8 @@ static bool Binary_Input_Inactive_Text_Write(
const char *idx_c; const char *idx_c;
char idx_cc[64]; char idx_cc[64];
index = Binary_Input_Instance_To_Index(object_instance); if (Binary_Input_Valid_Instance(object_instance)) {
if (index < max_binary_inputs) { index = Binary_Input_Instance_To_Index(object_instance);
CurrentBI = &BI_Descr[index]; CurrentBI = &BI_Descr[index];
length = characterstring_length(char_string); length = characterstring_length(char_string);
if (length <= sizeof(CurrentBI->Inactive_Text)) { if (length <= sizeof(CurrentBI->Inactive_Text)) {
@@ -884,7 +956,7 @@ int Binary_Input_Read_Property(
BACNET_BIT_STRING bit_string; BACNET_BIT_STRING bit_string;
BACNET_CHARACTER_STRING char_string; BACNET_CHARACTER_STRING char_string;
BACNET_BINARY_PV present_value = 0; BACNET_BINARY_PV present_value = 0;
unsigned object_index = 0; unsigned index = 0;
unsigned i = 0; unsigned i = 0;
uint8_t *apdu = NULL; uint8_t *apdu = NULL;
@@ -894,12 +966,10 @@ int Binary_Input_Read_Property(
} }
apdu = rpdata->application_data; apdu = rpdata->application_data;
object_index = Binary_Input_Instance_To_Index(rpdata->object_instance); if (Binary_Input_Valid_Instance(rpdata->object_instance)) {
if (object_index < max_binary_inputs) index = Binary_Input_Instance_To_Index(rpdata->object_instance);
CurrentBI = &BI_Descr[object_index]; CurrentBI = &BI_Descr[index];
else } else
return BACNET_STATUS_ERROR;
if (CurrentBI->Disable)
return BACNET_STATUS_ERROR; return BACNET_STATUS_ERROR;
//fprintf(stderr,"object_property: %i\n", rpdata->object_property); //fprintf(stderr,"object_property: %i\n", rpdata->object_property);
@@ -990,7 +1060,7 @@ int Binary_Input_Read_Property(
} else if (rpdata->array_index == BACNET_ARRAY_ALL) { } else if (rpdata->array_index == BACNET_ARRAY_ALL) {
for (i = 0; i < BACNET_MAX_PRIORITY; i++) { for (i = 0; i < BACNET_MAX_PRIORITY; i++) {
/* FIXME: check if we have room before adding it to APDU */ /* FIXME: check if we have room before adding it to APDU */
if (CurrentBI->Priority_Array[i] == BINARY_NULL) { if (CurrentBI->Priority_Array[i] == BINARY_LEVEL_NULL) {
len = encode_application_null(&apdu[apdu_len]); len = encode_application_null(&apdu[apdu_len]);
} else { } else {
present_value = CurrentBI->Priority_Array[i]; present_value = CurrentBI->Priority_Array[i];
@@ -1011,7 +1081,7 @@ int Binary_Input_Read_Property(
} else { } else {
if (rpdata->array_index <= BACNET_MAX_PRIORITY) { if (rpdata->array_index <= BACNET_MAX_PRIORITY) {
if (CurrentBI->Priority_Array[rpdata->array_index - 1] if (CurrentBI->Priority_Array[rpdata->array_index - 1]
== BINARY_NULL) == BINARY_LEVEL_NULL)
apdu_len = encode_application_null(&apdu[0]); apdu_len = encode_application_null(&apdu[0]);
else { else {
present_value = present_value =
@@ -1175,16 +1245,19 @@ bool Binary_Input_Write_Property(
{ {
BINARY_INPUT_DESCR *CurrentBI; BINARY_INPUT_DESCR *CurrentBI;
bool status = false; /* return value */ bool status = false; /* return value */
unsigned int object_index = 0; unsigned int index = 0;
int object_type = 0; int object_type = 0;
uint32_t object_instance = 0; uint32_t object_instance = 0;
unsigned int priority = 0; unsigned int priority = 0;
uint8_t level = BINARY_NULL; uint8_t level = BINARY_LEVEL_NULL;
int len = 0; int len = 0;
BACNET_APPLICATION_DATA_VALUE value; BACNET_APPLICATION_DATA_VALUE value;
ctx = ucix_init("bacnet_bi"); ctx = ucix_init("bacnet_bi");
const char index_c[32] = ""; const char index_c[32] = "";
const char *idx_c; const char *idx_c;
BACNET_BINARY_PV pvalue = 0;
int i;
time_t cur_value_time;
char idx_cc[64]; char idx_cc[64];
/* decode the some of the request */ /* decode the some of the request */
@@ -1205,10 +1278,10 @@ bool Binary_Input_Write_Property(
return false; return false;
} }
object_index = Binary_Input_Instance_To_Index(wp_data->object_instance); if (Binary_Input_Valid_Instance(wp_data->object_instance)) {
if (object_index < max_binary_inputs) { index = Binary_Input_Instance_To_Index(wp_data->object_instance);
CurrentBI = &BI_Descr[object_index]; CurrentBI = &BI_Descr[index];
sprintf(idx_cc,"%d",object_index); sprintf(idx_cc,"%d",index);
idx_c = idx_cc; idx_c = idx_cc;
} else } else
return false; return false;
@@ -1265,6 +1338,13 @@ bool Binary_Input_Write_Property(
if (Binary_Input_Present_Value_Set(wp_data->object_instance, if (Binary_Input_Present_Value_Set(wp_data->object_instance,
value.type.Unsigned_Int, wp_data->priority)) { value.type.Unsigned_Int, wp_data->priority)) {
status = true; status = true;
ucix_add_option_int(ctx, "bacnet_bi", idx_c, "value",
value.type.Unsigned_Int);
cur_value_time = time(NULL);
ucix_add_option_int(ctx, "bacnet_bi", idx_c, "value_time",
cur_value_time);
ucix_add_option_int(ctx, "bacnet_bi", idx_c, "write",
1);
} else if (wp_data->priority == 6) { } else if (wp_data->priority == 6) {
/* Command priority 6 is reserved for use by Minimum On/Off /* Command priority 6 is reserved for use by Minimum On/Off
algorithm and may not be used for other purposes in any algorithm and may not be used for other purposes in any
@@ -1280,7 +1360,7 @@ bool Binary_Input_Write_Property(
WPValidateArgType(&value, BACNET_APPLICATION_TAG_NULL, WPValidateArgType(&value, BACNET_APPLICATION_TAG_NULL,
&wp_data->error_class, &wp_data->error_code); &wp_data->error_class, &wp_data->error_code);
if (status) { if (status) {
level = BINARY_NULL; level = BINARY_LEVEL_NULL;
priority = wp_data->priority; priority = wp_data->priority;
if (priority && (priority <= BACNET_MAX_PRIORITY)) { if (priority && (priority <= BACNET_MAX_PRIORITY)) {
priority--; priority--;
@@ -1291,6 +1371,20 @@ bool Binary_Input_Write_Property(
However, if Out of Service is TRUE, then don't set the However, if Out of Service is TRUE, then don't set the
physical output. This comment may apply to the physical output. This comment may apply to the
main loop (i.e. check out of service before changing output) */ main loop (i.e. check out of service before changing output) */
pvalue = CurrentBI->Relinquish_Default;
for (i = 0; i < BACNET_MAX_PRIORITY; i++) {
if (CurrentBI->Priority_Array[i] != BINARY_LEVEL_NULL) {
pvalue = CurrentBI->Priority_Array[i];
break;
}
}
ucix_add_option_int(ctx, "bacnet_bi", idx_c, "value",
pvalue);
cur_value_time = time(NULL);
ucix_add_option_int(ctx, "bacnet_bi", idx_c, "value_time",
cur_value_time);
ucix_add_option_int(ctx, "bacnet_bi", idx_c, "write",
1);
} else { } else {
status = false; status = false;
wp_data->error_class = ERROR_CLASS_PROPERTY; wp_data->error_class = ERROR_CLASS_PROPERTY;
@@ -1481,16 +1575,16 @@ void Binary_Input_Intrinsic_Reporting(
BINARY_INPUT_DESCR *CurrentBI; BINARY_INPUT_DESCR *CurrentBI;
BACNET_EVENT_NOTIFICATION_DATA event_data; BACNET_EVENT_NOTIFICATION_DATA event_data;
BACNET_CHARACTER_STRING msgText; BACNET_CHARACTER_STRING msgText;
unsigned int object_index; unsigned int index;
uint8_t FromState = 0; uint8_t FromState = 0;
uint8_t ToState; uint8_t ToState;
uint8_t PresentVal = 0; uint8_t PresentVal = 0;
bool SendNotify = false; bool SendNotify = false;
bool tonormal = true; bool tonormal = true;
object_index = Binary_Input_Instance_To_Index(object_instance); index = Binary_Input_Instance_To_Index(object_instance);
if (object_index < max_binary_inputs) if (index < max_binary_inputs_int)
CurrentBI = &BI_Descr[object_index]; CurrentBI = &BI_Descr[index];
else else
return; return;
@@ -1717,8 +1811,7 @@ int Binary_Input_Event_Information(
/* check index */ /* check index */
if (index < max_binary_inputs) { if (Binary_Input_Valid_Instance(index)) {
//CurrentBI = &BI_Descr[index];
/* Event_State not equal to NORMAL */ /* Event_State not equal to NORMAL */
IsActiveEvent = (BI_Descr[index].Event_State != EVENT_STATE_NORMAL); IsActiveEvent = (BI_Descr[index].Event_State != EVENT_STATE_NORMAL);
@@ -1786,16 +1879,14 @@ int Binary_Input_Alarm_Ack(
BACNET_ERROR_CODE * error_code) BACNET_ERROR_CODE * error_code)
{ {
BINARY_INPUT_DESCR *CurrentBI; BINARY_INPUT_DESCR *CurrentBI;
unsigned int object_index; unsigned int index;
if (Binary_Input_Valid_Instance(alarmack_data->
object_index = eventObjectIdentifier.instance)) {
Binary_Input_Instance_To_Index(alarmack_data-> index = Binary_Input_Instance_To_Index(alarmack_data->
eventObjectIdentifier.instance); eventObjectIdentifier.instance);
CurrentBI = &BI_Descr[index];
if (object_index < max_binary_inputs) } else {
CurrentBI = &BI_Descr[object_index];
else {
*error_code = ERROR_CODE_UNKNOWN_OBJECT; *error_code = ERROR_CODE_UNKNOWN_OBJECT;
return -1; return -1;
} }
@@ -1887,8 +1978,9 @@ int Binary_Input_Alarm_Summary(
BACNET_GET_ALARM_SUMMARY_DATA * getalarm_data) BACNET_GET_ALARM_SUMMARY_DATA * getalarm_data)
{ {
BINARY_INPUT_DESCR *CurrentBI; BINARY_INPUT_DESCR *CurrentBI;
/* check index */ /* check index */
if (index < max_binary_inputs) { if (index < max_binary_inputs_int) {
CurrentBI = &BI_Descr[index]; CurrentBI = &BI_Descr[index];
/* Event_State is not equal to NORMAL and /* Event_State is not equal to NORMAL and
Notify_Type property value is ALARM */ Notify_Type property value is ALARM */

29
demo/object/bi.h
View File

@@ -31,6 +31,7 @@
#include <stdint.h> #include <stdint.h>
#include "bacdef.h" #include "bacdef.h"
#include "cov.h" #include "cov.h"
#include "bacerror.h"
#include "rp.h" #include "rp.h"
#include "wp.h" #include "wp.h"
#if defined(INTRINSIC_REPORTING) #if defined(INTRINSIC_REPORTING)
@@ -44,9 +45,8 @@
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
int max_binary_inputs;
typedef struct binary_input_descr { typedef struct binary_input_descr {
uint32_t Instance;
char Object_Name[64]; char Object_Name[64];
char Object_Description[64]; char Object_Description[64];
BACNET_BINARY_PV Present_Value; BACNET_BINARY_PV Present_Value;
@@ -77,6 +77,28 @@ int max_binary_inputs;
} BINARY_INPUT_DESCR; } BINARY_INPUT_DESCR;
/* value/name tuples */
struct bi_inst_tuple {
char idx[18];
struct bi_inst_tuple *next;
};
typedef struct bi_inst_tuple bi_inst_tuple_t;
/* structure to hold tuple-list and uci context during iteration */
struct bi_inst_itr_ctx {
struct bi_inst_tuple *list;
struct uci_context *ctx;
char *section;
};
void Binary_Input_Load_UCI_List(
const char *sec_idx,
struct bi_inst_itr_ctx *itr);
void Binary_Input_Property_Lists( void Binary_Input_Property_Lists(
const int **pRequired, const int **pRequired,
const int **pOptional, const int **pOptional,
@@ -168,6 +190,9 @@ int max_binary_inputs;
BACNET_BINARY_PV value, BACNET_BINARY_PV value,
uint8_t priority); uint8_t priority);
unsigned Binary_Input_Present_Value_Priority(
uint32_t object_instance);
/* note: header of Intrinsic_Reporting function is required /* note: header of Intrinsic_Reporting function is required
even when INTRINSIC_REPORTING is not defined */ even when INTRINSIC_REPORTING is not defined */
void Binary_Input_Intrinsic_Reporting( void Binary_Input_Intrinsic_Reporting(

2
demo/object/device.c
View File

@@ -154,7 +154,6 @@ static object_functions_t My_Object_Table[] = {
Analog_Value_Change_Of_Value, Analog_Value_Change_Of_Value,
Analog_Value_Change_Of_Value_Clear, Analog_Value_Change_Of_Value_Clear,
Analog_Value_Intrinsic_Reporting}, Analog_Value_Intrinsic_Reporting},
#if 0
{OBJECT_BINARY_INPUT, {OBJECT_BINARY_INPUT,
Binary_Input_Init, Binary_Input_Init,
Binary_Input_Count, Binary_Input_Count,
@@ -170,6 +169,7 @@ static object_functions_t My_Object_Table[] = {
Binary_Input_Change_Of_Value, Binary_Input_Change_Of_Value,
Binary_Input_Change_Of_Value_Clear, Binary_Input_Change_Of_Value_Clear,
Binary_Input_Intrinsic_Reporting}, Binary_Input_Intrinsic_Reporting},
#if 0
{OBJECT_BINARY_OUTPUT, {OBJECT_BINARY_OUTPUT,
Binary_Output_Init, Binary_Output_Init,
Binary_Output_Count, Binary_Output_Count,