Skip to content

osie
osie
Commit 3dbb96ce authored by Ivan Tyagov's avatar Ivan Tyagov
Browse files
Options

Feature/coupler opcua integration 

See merge request !12
parents ff0f5eb0 33d09fd1
Hide whitespace changes
Inline Side-by-side
Showing with 808 additions and 160 deletions
coupler/opc-ua-server/server.c
View file @ 3dbb96ce
...@@ -33,27 +33,29 @@ const char *argp_program_version = "OSIE OPC-UA coupler 0.0.1"; ...@@ -33,27 +33,29 @@ const char *argp_program_version = "OSIE OPC-UA coupler 0.0.1";
const char *argp_program_bug_address = "ivan@nexedi.com"; const char *argp_program_bug_address = "ivan@nexedi.com";
static char doc[] = "OPC-UA server which controls MOD-IO's relays' state over OPC-UA protocol."; static char doc[] = "OPC-UA server which controls MOD-IO's relays' state over OPC-UA protocol.";
static char args_doc[] = "..."; static char args_doc[] = "...";
static struct argp_option options[] = { static struct argp_option options[] = {
{ "port", 'p', "4840", 0, "Port to bind to."}, {"port", 'p', "4840", 0, "Port to bind to."},
{ "device", 'd', "/dev/i2c-1", 0, "Linux block device path."}, {"device", 'd', "/dev/i2c-1", 0, "Linux block device path."},
{ "slave-address-list", 's', "0x58", 0, "Comma separated list of slave I2C addresses."}, {"slave-address-list", 's', "0x58", 0, "Comma separated list of slave I2C addresses."},
{ "mode", 'm', "0", 0, "Set different modes of operation of coupler. Default (0) is set attached \ {"mode", 'm', "0", 0, "Set different modes of operation of coupler. Default (0) is set attached \
I2C's state state. Virtual (1) which does NOT set any I2C slaves' state."}, I2C's state state. Virtual (1) which does NOT set any I2C slaves' state."},
{ "username", 'u', "", 0, "Username."}, { "username", 'u', "", 0, "Username."},
{ "password", 'w', "", 0, "Password."}, { "password", 'w', "", 0, "Password."},
{ 0 } { 0 }
}; };
struct arguments { struct arguments
int mode; {
int port; int mode;
int port;
char *device; char *device;
char *slave_address_list; char *slave_address_list;
char *username; char *username;
char *password; char *password;
}; };
static error_t parse_opt(int key, char *arg, struct argp_state *state) { static error_t parse_opt(int key, char *arg, struct argp_state *state)
{
struct arguments *arguments = state->input; struct arguments *arguments = state->input;
switch (key) { switch (key) {
case 'p': case 'p':
...@@ -82,7 +84,7 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) { ...@@ -82,7 +84,7 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
return 0; return 0;
} }
static struct argp argp = { options, parse_opt, args_doc, doc, 0, 0, 0 }; static struct argp argp = {options, parse_opt, args_doc, doc, 0, 0, 0};
// global relay state // global relay state
uint8_t I2C_0_RELAYS_STATE = 0; // state of 4 relays at I2C slave 0 uint8_t I2C_0_RELAYS_STATE = 0; // state of 4 relays at I2C slave 0
...@@ -104,7 +106,8 @@ char *I2C_BLOCK_DEVICE_NAME; ...@@ -104,7 +106,8 @@ char *I2C_BLOCK_DEVICE_NAME;
// global virtual mode needed for testing on x86 platform // global virtual mode needed for testing on x86 platform
bool I2C_VIRTUAL_MODE = 0; bool I2C_VIRTUAL_MODE = 0;
static int getI2CSlaveListLength() { static int getI2CSlaveListLength()
{
/* /*
* Return ONLY registred I2C slaves * Return ONLY registred I2C slaves
*/ */
...@@ -113,38 +116,43 @@ static int getI2CSlaveListLength() { ...@@ -113,38 +116,43 @@ static int getI2CSlaveListLength() {
int counter = 0; int counter = 0;
int length = sizeof(I2C_SLAVE_ADDR_LIST) / sizeof(int); int length = sizeof(I2C_SLAVE_ADDR_LIST) / sizeof(int);
for(i = 0; i < length; i++) for (i = 0; i < length; i++)
{ {
addr = I2C_SLAVE_ADDR_LIST[i]; addr = I2C_SLAVE_ADDR_LIST[i];
if (addr!= 0) { if (addr != 0)
counter++; {
counter++;
} }
} }
return counter; return counter;
} }
static int setRelayState(int command, int i2c_addr) { static int setRelayState(int command, int i2c_addr)
{
/* /*
* Set relays' state over I2C * Set relays' state over I2C
*/ */
int file; int file;
char filename[20]; char filename[20];
if(I2C_VIRTUAL_MODE){ if (I2C_VIRTUAL_MODE)
// we're in a virtual mode, likely on x86 platform or without I2C support {
// simply do nothing // we're in a virtual mode, likely on x86 platform or without I2C support
return 0; // simply do nothing
return 0;
} }
// step 1: open device // step 1: open device
file = open(I2C_BLOCK_DEVICE_NAME, O_RDWR); file = open(I2C_BLOCK_DEVICE_NAME, O_RDWR);
if (file < 0) { if (file < 0)
{
/* ERROR HANDLING; you can check errno to see what went wrong */ /* ERROR HANDLING; you can check errno to see what went wrong */
printf("Error opening i2c device (0x%x).\n", i2c_addr); printf("Error opening i2c device (0x%x).\n", i2c_addr);
exit(1); exit(1);
} }
// step 2: address the slave by its address // step 2: address the slave by its address
if (ioctl(file, I2C_SLAVE, i2c_addr) < 0) { if (ioctl(file, I2C_SLAVE, i2c_addr) < 0)
{
/* ERROR HANDLING; you can check errno to see what went wrong */ /* ERROR HANDLING; you can check errno to see what went wrong */
printf("Error addressing i2c slave (0x%x).\n", i2c_addr); printf("Error addressing i2c slave (0x%x).\n", i2c_addr);
exit(1); exit(1);
...@@ -152,23 +160,140 @@ static int setRelayState(int command, int i2c_addr) { ...@@ -152,23 +160,140 @@ static int setRelayState(int command, int i2c_addr) {
// step 3: write command over I2c // step 3: write command over I2c
__u8 reg = 0x10; /* Device register to access */ __u8 reg = 0x10; /* Device register to access */
__s32 res;
char buf[10]; char buf[10];
buf[0] = reg; buf[0] = reg;
buf[1] = command; //0x00 -all off, 0x0F - all 4 on buf[1] = command; //0x00 -all off, 0x0F - all 4 on
buf[2] = 0x65; // seems irrelevant the value if (write(file, buf, 3) != 3)
if (write(file, buf, 3) != 3) { {
/* ERROR HANDLING: i2c transaction failed */ /* ERROR HANDLING: i2c transaction failed */
printf("Error writing to i2c slave (0x%x).\n", i2c_addr); printf("Error writing to i2c slave (0x%x).\n", i2c_addr);
} }
close(file); close(file);
} }
void addIntegerVariableNode(UA_Server *server, char *node_id, char *node_description) { static int getDigitalInputState(int i2c_addr, char **digital_input)
{
/*
* get digital input state over I2C
*/
int file;
char filename[20];
if (I2C_VIRTUAL_MODE)
{
// we're in a virtual mode, likely on x86 platform or without I2C support
// simply do nothing
return 0;
}
// step 1: open device
file = open(I2C_BLOCK_DEVICE_NAME, O_RDWR);
if (file < 0)
{
/* ERROR HANDLING; you can check errno to see what went wrong */
printf("Error opening i2c device (0x%x).\n", i2c_addr);
exit(1);
}
// step 2: address the slave by its address
if (ioctl(file, I2C_SLAVE, i2c_addr) < 0)
{
/* ERROR HANDLING; you can check errno to see what went wrong */
printf("Error addressing i2c slave (0x%x).\n", i2c_addr);
exit(1);
}
// step 3: write command over I2c
__u8 read_reg = 0x20; /* Device register to access */
char read_buf[2];
read_buf[0] = read_reg;
if (write(file, read_buf, 1) != 1)
{
/* ERROR HANDLING: i2c transaction failed */
printf("Error writing to i2c slave (0x%x).\n", i2c_addr);
}
if (read(file, read_buf, 1) != 1)
{
/* ERROR HANDLING: i2c transaction failed */
printf("Error reading digital input from i2c slave (0x%x).\n", i2c_addr);
}
else
{
/* read_buf[0] contains the read byte */
*digital_input = &read_buf[0];
}
close(file);
}
static int getAnalogInputStateAIN(int i2c_addr, int **analog_input, uint8_t read_reg)
{
/*
* get digital input state over I2C
*/
int file;
char filename[20];
if (I2C_VIRTUAL_MODE)
{
// we're in a virtual mode, likely on x86 platform or without I2C support
// simply do nothing
return 0;
}
// step 1: open device
file = open(I2C_BLOCK_DEVICE_NAME, O_RDWR);
if (file < 0)
{
/* ERROR HANDLING; you can check errno to see what went wrong */
printf("Error opening i2c device (0x%x).\n", i2c_addr);
exit(1);
}
// step 2: address the slave by its address
if (ioctl(file, I2C_SLAVE, i2c_addr) < 0)
{
/* ERROR HANDLING; you can check errno to see what went wrong */
printf("Error addressing i2c slave (0x%x).\n", i2c_addr);
exit(1);
}
// step 3: write command over I2c
//__u8 read_reg = 0x30; /* Device register to access */
char read_buf[10];
read_buf[0] = read_reg;
if (write(file, read_buf, 1) != 1)
{
/* ERROR HANDLING: i2c transaction failed */
printf("Error writing to i2c slave (0x%x).\n", i2c_addr);
}
if (read(file, read_buf, 1) != 1)
{
/* ERROR HANDLING: i2c transaction failed */
printf("Error reading analog input from i2c slave (0x%x).\n", i2c_addr);
}
else
{
/* Since read_buf[0] is (LSB:MSB) we need to convert it to (MSB:LSB). To swap bits one by one do
the following */
int analog_data = 0;
for (int index = 0; index < 8; index++)
{
analog_data |= ((read_buf[0] & 0x80) ? 1 : 0) << index;
read_buf[0] <<= 1;
}
/* Now add the high 2 bit to the value */
analog_data |= ((read_buf[1] & 0x02) ? 1 : 0) << 8;
analog_data |= ((read_buf[1] & 0x01) ? 1 : 0) << 9;
*analog_input = &analog_data;
}
close(file);
}
void addIntegerVariableNode(UA_Server *server, char *node_id, char *node_description)
{
UA_Int32 myInteger = 0; UA_Int32 myInteger = 0;
UA_NodeId parentNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER); UA_NodeId parentNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER);
UA_NodeId parentReferenceNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES); UA_NodeId parentReferenceNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES);
UA_VariableAttributes attr0 = UA_VariableAttributes_default; UA_VariableAttributes attr0 = UA_VariableAttributes_default;
UA_Variant_setScalar(&attr0.value, &myInteger, &UA_TYPES[UA_TYPES_INT32]); UA_Variant_setScalar(&attr0.value, &myInteger, &UA_TYPES[UA_TYPES_INT32]);
attr0.description = UA_LOCALIZEDTEXT("en-US", node_description); attr0.description = UA_LOCALIZEDTEXT("en-US", node_description);
...@@ -180,27 +305,83 @@ void addIntegerVariableNode(UA_Server *server, char *node_id, char *node_descrip ...@@ -180,27 +305,83 @@ void addIntegerVariableNode(UA_Server *server, char *node_id, char *node_descrip
UA_Server_addVariableNode(server, myIntegerNodeId0, parentNodeId, UA_Server_addVariableNode(server, myIntegerNodeId0, parentNodeId,
parentReferenceNodeId, myIntegerName0, parentReferenceNodeId, myIntegerName0,
UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), attr0, NULL, NULL); UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), attr0, NULL, NULL);
} }
static void addVariable(UA_Server *server) { void addUIntegerVariableReadNode(UA_Server *server, char *node_id, char *node_description)
{
UA_UInt32 myInteger = 0;
UA_NodeId parentNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER);
UA_NodeId parentReferenceNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES);
UA_VariableAttributes attr0 = UA_VariableAttributes_default;
UA_Variant_setScalar(&attr0.value, &myInteger, &UA_TYPES[UA_TYPES_UINT32]);
attr0.description = UA_LOCALIZEDTEXT("en-US", node_description);
attr0.displayName = UA_LOCALIZEDTEXT("en-US", node_description);
attr0.dataType = UA_TYPES[UA_TYPES_UINT32].typeId;
attr0.accessLevel = UA_ACCESSLEVELMASK_READ;
UA_NodeId myIntegerNodeId0 = UA_NODEID_STRING(1, node_id);
UA_QualifiedName myIntegerName0 = UA_QUALIFIEDNAME(1, node_description);
UA_Server_addVariableNode(server, myIntegerNodeId0, parentNodeId,
parentReferenceNodeId, myIntegerName0,
UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), attr0, NULL, NULL);
}
void addBooleanVariableReadNode(UA_Server *server, char *node_id, char *node_description)
{
UA_Boolean myBoolean = false;
UA_NodeId parentNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER);
UA_NodeId parentReferenceNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES);
UA_VariableAttributes attr0 = UA_VariableAttributes_default;
UA_Variant_setScalar(&attr0.value, &myBoolean, &UA_TYPES[UA_TYPES_BOOLEAN]);
attr0.description = UA_LOCALIZEDTEXT("en-US", node_description);
attr0.displayName = UA_LOCALIZEDTEXT("en-US", node_description);
attr0.dataType = UA_TYPES[UA_TYPES_BOOLEAN].typeId;
attr0.accessLevel = UA_ACCESSLEVELMASK_READ;
UA_NodeId myIntegerNodeId0 = UA_NODEID_STRING(1, node_id);
UA_QualifiedName myIntegerName0 = UA_QUALIFIEDNAME(1, node_description);
UA_Server_addVariableNode(server, myIntegerNodeId0, parentNodeId,
parentReferenceNodeId, myIntegerName0,
UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), attr0, NULL, NULL);
}
static void addVariable(UA_Server *server)
{
/* /*
* Create all variables representing MOD-IO's relays * Create all variables representing MOD-IO's relays
*/ */
int length = getI2CSlaveListLength(); int length = getI2CSlaveListLength();
if (length>=1) { if (length >= 1)
{
// IC2-0 // IC2-0
addIntegerVariableNode(server, "i2c0.relay0", "I2C0 / Relay 0"); addIntegerVariableNode(server, "i2c0.relay0", "I2C0 / Relay 0");
addIntegerVariableNode(server, "i2c0.relay1", "I2C0 / Relay 1"); addIntegerVariableNode(server, "i2c0.relay1", "I2C0 / Relay 1");
addIntegerVariableNode(server, "i2c0.relay2", "I2C0 / Relay 2"); addIntegerVariableNode(server, "i2c0.relay2", "I2C0 / Relay 2");
addIntegerVariableNode(server, "i2c0.relay3", "I2C0 / Relay 3"); addIntegerVariableNode(server, "i2c0.relay3", "I2C0 / Relay 3");
addBooleanVariableReadNode(server, "i2c0.in0", "I2C0 / Digital Input 0");
addBooleanVariableReadNode(server, "i2c0.in1", "I2C0 / Digital Input 1");
addBooleanVariableReadNode(server, "i2c0.in2", "I2C0 / Digital Input 2");
addBooleanVariableReadNode(server, "i2c0.in3", "I2C0 / Digital Input 3");
addUIntegerVariableReadNode(server, "i2c0.ain0", "I2C0 / Analog Input 0");
addUIntegerVariableReadNode(server, "i2c0.ain1", "I2C0 / Analog Input 1");
addUIntegerVariableReadNode(server, "i2c0.ain2", "I2C0 / Analog Input 2");
addUIntegerVariableReadNode(server, "i2c0.ain3", "I2C0 / Analog Input 3");
} }
if (length>=2) { if (length >= 2)
{
// IC2-1 // IC2-1
addIntegerVariableNode(server, "i2c1.relay0", "I2C1 / Relay 0"); addIntegerVariableNode(server, "i2c1.relay0", "I2C1 / Relay 0");
addIntegerVariableNode(server, "i2c1.relay1", "I2C1 / Relay 1"); addIntegerVariableNode(server, "i2c1.relay1", "I2C1 / Relay 1");
addIntegerVariableNode(server, "i2c1.relay2", "I2C1 / Relay 2"); addIntegerVariableNode(server, "i2c1.relay2", "I2C1 / Relay 2");
addIntegerVariableNode(server, "i2c1.relay3", "I2C1 / Relay 3"); addIntegerVariableNode(server, "i2c1.relay3", "I2C1 / Relay 3");
addBooleanVariableReadNode(server, "i2c1.in0", "I2C1 / Digital Input 0");
addBooleanVariableReadNode(server, "i2c1.in1", "I2C1 / Digital Input 1");
addBooleanVariableReadNode(server, "i2c1.in2", "I2C1 / Digital Input 2");
addBooleanVariableReadNode(server, "i2c1.in3", "I2C1 / Digital Input 3");
addUIntegerVariableReadNode(server, "i2c1.ain0", "I2C1 / Analog Input 0");
addUIntegerVariableReadNode(server, "i2c1.ain1", "I2C1 / Analog Input 1");
addUIntegerVariableReadNode(server, "i2c1.ain2", "I2C1 / Analog Input 2");
addUIntegerVariableReadNode(server, "i2c1.ain3", "I2C1 / Analog Input 3");
} }
} }
...@@ -208,226 +389,686 @@ static void addVariable(UA_Server *server) { ...@@ -208,226 +389,686 @@ static void addVariable(UA_Server *server) {
* *
*/ */
static void beforeReadTime(UA_Server *server, static void beforeReadTime(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext, const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeid, void *nodeContext, const UA_NodeId *nodeid, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data) { const UA_NumericRange *range, const UA_DataValue *data)
{
}
static void beforeReadTimeI2C0Ain0(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeid, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data)
{
int addr = I2C_SLAVE_ADDR_LIST[0];
int *data_input = 0;
uint8_t read_addr =0x30;
getAnalogInputStateAIN(addr, &data_input, read_addr);
if (data->value.type == &UA_TYPES[UA_TYPES_UINT32])
{
*(UA_UInt32 *)data->value.data = *data_input;
}
}
static void beforeReadTimeI2C0Ain1(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeid, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data)
{
int addr = I2C_SLAVE_ADDR_LIST[0];
int *data_input = 0;
uint8_t read_addr =0x31;
getAnalogInputStateAIN(addr, &data_input, read_addr);
if (data->value.type == &UA_TYPES[UA_TYPES_UINT32])
{
*(UA_UInt32 *)data->value.data = *data_input;
}
}
static void beforeReadTimeI2C0Ain2(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeid, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data)
{
int addr = I2C_SLAVE_ADDR_LIST[0];
int *data_input = 0;
uint8_t read_addr =0x32;
getAnalogInputStateAIN(addr, &data_input, read_addr);
if (data->value.type == &UA_TYPES[UA_TYPES_UINT32])
{
*(UA_UInt32 *)data->value.data = *data_input;
}
}
static void beforeReadTimeI2C0Ain3(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeid, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data)
{
int addr = I2C_SLAVE_ADDR_LIST[0];
int *data_input = 0;
uint8_t read_addr =0x33;
getAnalogInputStateAIN(addr, &data_input, read_addr);
if (data->value.type == &UA_TYPES[UA_TYPES_UINT32])
{
*(UA_UInt32 *)data->value.data = *data_input;
}
}
static void beforeReadTimeI2C1Ain0(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeid, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data)
{
int addr = I2C_SLAVE_ADDR_LIST[1];
int *data_input = 0;
uint8_t read_addr =0x30;
getAnalogInputStateAIN(addr, &data_input, read_addr);
if (data->value.type == &UA_TYPES[UA_TYPES_UINT32])
{
*(UA_UInt32 *)data->value.data = *data_input;
}
}
static void beforeReadTimeI2C1Ain1(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeid, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data)
{
int addr = I2C_SLAVE_ADDR_LIST[1];
int *data_input = 0;
uint8_t read_addr =0x31;
getAnalogInputStateAIN(addr, &data_input, read_addr);
if (data->value.type == &UA_TYPES[UA_TYPES_UINT32])
{
*(UA_UInt32 *)data->value.data = *data_input;
}
}
static void beforeReadTimeI2C1Ain2(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeid, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data)
{
int addr = I2C_SLAVE_ADDR_LIST[1];
int *data_input = 0;
uint8_t read_addr =0x32;
getAnalogInputStateAIN(addr, &data_input, read_addr);
if (data->value.type == &UA_TYPES[UA_TYPES_UINT32])
{
*(UA_UInt32 *)data->value.data = *data_input;
}
}
static void beforeReadTimeI2C1Ain3(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeid, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data)
{
int addr = I2C_SLAVE_ADDR_LIST[1];
int *data_input = 0;
uint8_t read_addr =0x33;
getAnalogInputStateAIN(addr, &data_input, read_addr);
if (data->value.type == &UA_TYPES[UA_TYPES_UINT32])
{
*(UA_UInt32 *)data->value.data = *data_input;
}
}
static void beforeReadTimeI2C0In0(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeid, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data)
{
int addr = I2C_SLAVE_ADDR_LIST[0];
char *data_input = 0;
getDigitalInputState(addr, &data_input);
if ((*data_input) & (1UL << 0))
{
if (data->value.type == &UA_TYPES[UA_TYPES_BOOLEAN])
{
*(UA_Boolean *)data->value.data = true;
}
}
else
{
if (data->value.type == &UA_TYPES[UA_TYPES_BOOLEAN])
{
*(UA_Boolean *)data->value.data = false;
}
}
}
static void beforeReadTimeI2C0In1(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeid, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data)
{
int addr = I2C_SLAVE_ADDR_LIST[0];
char *data_input = 0;
getDigitalInputState(addr, &data_input);
if ((*data_input) & (1UL << 1))
{
if (data->value.type == &UA_TYPES[UA_TYPES_BOOLEAN])
{
*(UA_Boolean *)data->value.data = true;
}
}
else
{
if (data->value.type == &UA_TYPES[UA_TYPES_BOOLEAN])
{
*(UA_Boolean *)data->value.data = false;
}
}
}
static void beforeReadTimeI2C0In2(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeid, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data)
{
int addr = I2C_SLAVE_ADDR_LIST[0];
char *data_input = 0;
getDigitalInputState(addr, &data_input);
if ((*data_input) & (1UL << 2))
{
if (data->value.type == &UA_TYPES[UA_TYPES_BOOLEAN])
{
*(UA_Boolean *)data->value.data = true;
}
}
else
{
if (data->value.type == &UA_TYPES[UA_TYPES_BOOLEAN])
{
*(UA_Boolean *)data->value.data = false;
}
}
}
static void beforeReadTimeI2C0In3(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeid, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data)
{
int addr = I2C_SLAVE_ADDR_LIST[0];
char *data_input = 0;
getDigitalInputState(addr, &data_input);
if ((*data_input) & (1UL << 3))
{
if (data->value.type == &UA_TYPES[UA_TYPES_BOOLEAN])
{
*(UA_Boolean *)data->value.data = true;
}
}
else
{
if (data->value.type == &UA_TYPES[UA_TYPES_BOOLEAN])
{
*(UA_Boolean *)data->value.data = false;
}
}
}
static void beforeReadTimeI2C1In0(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeid, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data)
{
int addr = I2C_SLAVE_ADDR_LIST[1];
char *data_input = 0;
getDigitalInputState(addr, &data_input);
if ((*data_input) & (1UL << 0))
{
if (data->value.type == &UA_TYPES[UA_TYPES_BOOLEAN])
{
*(UA_Boolean *)data->value.data = true;
}
}
else
{
if (data->value.type == &UA_TYPES[UA_TYPES_BOOLEAN])
{
*(UA_Boolean *)data->value.data = false;
}
}
}
static void beforeReadTimeI2C1In1(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeid, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data)
{
int addr = I2C_SLAVE_ADDR_LIST[1];
char *data_input = 0;
getDigitalInputState(addr, &data_input);
if ((*data_input) & (1UL << 1))
{
if (data->value.type == &UA_TYPES[UA_TYPES_BOOLEAN])
{
*(UA_Boolean *)data->value.data = true;
}
}
else
{
if (data->value.type == &UA_TYPES[UA_TYPES_BOOLEAN])
{
*(UA_Boolean *)data->value.data = false;
}
}
}
static void beforeReadTimeI2C1In2(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeid, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data)
{
int addr = I2C_SLAVE_ADDR_LIST[1];
char *data_input = 0;
getDigitalInputState(addr, &data_input);
if ((*data_input) & (1UL << 2))
{
if (data->value.type == &UA_TYPES[UA_TYPES_BOOLEAN])
{
*(UA_Boolean *)data->value.data = true;
}
}
else
{
if (data->value.type == &UA_TYPES[UA_TYPES_BOOLEAN])
{
*(UA_Boolean *)data->value.data = false;
}
}
}
static void beforeReadTimeI2C1In3(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeid, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data)
{
int addr = I2C_SLAVE_ADDR_LIST[1];
char *data_input = 0;
getDigitalInputState(addr, &data_input);
if ((*data_input) & (1UL << 3))
{
if (data->value.type == &UA_TYPES[UA_TYPES_BOOLEAN])
{
*(UA_Boolean *)data->value.data = true;
}
}
else
{
if (data->value.type == &UA_TYPES[UA_TYPES_BOOLEAN])
{
*(UA_Boolean *)data->value.data = false;
}
}
}
static void afterWriteTime(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeId, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data)
{
// nothing to do as not yet needed. // nothing to do as not yet needed.
} }
// XXX: having afterWriteTime{0..3} is not needed and maybe with introspection of context we can // XXX: having afterWriteTime{0..3} is not needed and maybe with introspection of context we can
// write only one callback function // write only one callback function
static void afterWriteTimeI2C0_0(UA_Server *server, static void afterWriteTimeI2C0_0(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext, const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeId, void *nodeContext, const UA_NodeId *nodeId, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data) { const UA_NumericRange *range, const UA_DataValue *data)
if (data->value.type == &UA_TYPES[UA_TYPES_INT32]) { {
if (data->value.type == &UA_TYPES[UA_TYPES_INT32])
{
UA_Int32 hrValue = *(UA_Int32 *)data->value.data; UA_Int32 hrValue = *(UA_Int32 *)data->value.data;
int addr = I2C_SLAVE_ADDR_LIST[0]; int addr = I2C_SLAVE_ADDR_LIST[0];
if (hrValue > 0){ if (hrValue > 0)
I2C_0_RELAYS_STATE |= 1UL << 0; {
I2C_0_RELAYS_STATE |= 1UL << 0;
setRelayState(I2C_0_RELAYS_STATE, addr); setRelayState(I2C_0_RELAYS_STATE, addr);
} }
else { else
{
I2C_0_RELAYS_STATE &= ~(1UL << 0); I2C_0_RELAYS_STATE &= ~(1UL << 0);
setRelayState(I2C_0_RELAYS_STATE, addr); setRelayState(I2C_0_RELAYS_STATE, addr);
} }
} }
} }
static void afterWriteTimeI2C0_1(UA_Server *server, static void afterWriteTimeI2C0_1(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext, const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeId, void *nodeContext, const UA_NodeId *nodeId, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data) { const UA_NumericRange *range, const UA_DataValue *data)
if (data->value.type == &UA_TYPES[UA_TYPES_INT32]) { {
if (data->value.type == &UA_TYPES[UA_TYPES_INT32])
{
UA_Int32 hrValue = *(UA_Int32 *)data->value.data; UA_Int32 hrValue = *(UA_Int32 *)data->value.data;
int addr = I2C_SLAVE_ADDR_LIST[0]; int addr = I2C_SLAVE_ADDR_LIST[0];
if (hrValue > 0){ if (hrValue > 0)
{
I2C_0_RELAYS_STATE |= 1UL << 1; I2C_0_RELAYS_STATE |= 1UL << 1;
setRelayState(I2C_0_RELAYS_STATE, addr); setRelayState(I2C_0_RELAYS_STATE, addr);
} }
else { else
{
I2C_0_RELAYS_STATE &= ~(1UL << 1); I2C_0_RELAYS_STATE &= ~(1UL << 1);
setRelayState(I2C_0_RELAYS_STATE, addr); setRelayState(I2C_0_RELAYS_STATE, addr);
} }
} }
} }
static void afterWriteTimeI2C0_2(UA_Server *server, static void afterWriteTimeI2C0_2(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext, const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeId, void *nodeContext, const UA_NodeId *nodeId, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data) { const UA_NumericRange *range, const UA_DataValue *data)
if (data->value.type == &UA_TYPES[UA_TYPES_INT32]) { {
if (data->value.type == &UA_TYPES[UA_TYPES_INT32])
{
UA_Int32 hrValue = *(UA_Int32 *)data->value.data; UA_Int32 hrValue = *(UA_Int32 *)data->value.data;
int addr = I2C_SLAVE_ADDR_LIST[0]; int addr = I2C_SLAVE_ADDR_LIST[0];
if (hrValue > 0){ if (hrValue > 0)
{
I2C_0_RELAYS_STATE |= 1UL << 2; I2C_0_RELAYS_STATE |= 1UL << 2;
setRelayState(I2C_0_RELAYS_STATE, addr); setRelayState(I2C_0_RELAYS_STATE, addr);
} }
else { else
{
I2C_0_RELAYS_STATE &= ~(1UL << 2); I2C_0_RELAYS_STATE &= ~(1UL << 2);
setRelayState(I2C_0_RELAYS_STATE, addr); setRelayState(I2C_0_RELAYS_STATE, addr);
} }
} }
} }
static void afterWriteTimeI2C0_3(UA_Server *server, static void afterWriteTimeI2C0_3(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext, const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeId, void *nodeContext, const UA_NodeId *nodeId, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data) { const UA_NumericRange *range, const UA_DataValue *data)
if (data->value.type == &UA_TYPES[UA_TYPES_INT32]) { {
if (data->value.type == &UA_TYPES[UA_TYPES_INT32])
{
UA_Int32 hrValue = *(UA_Int32 *)data->value.data; UA_Int32 hrValue = *(UA_Int32 *)data->value.data;
int addr = I2C_SLAVE_ADDR_LIST[0]; int addr = I2C_SLAVE_ADDR_LIST[0];
if (hrValue > 0){ if (hrValue > 0)
{
I2C_0_RELAYS_STATE |= 1UL << 3; I2C_0_RELAYS_STATE |= 1UL << 3;
setRelayState(I2C_0_RELAYS_STATE, addr); setRelayState(I2C_0_RELAYS_STATE, addr);
} }
else { else
{
I2C_0_RELAYS_STATE &= ~(1UL << 3); I2C_0_RELAYS_STATE &= ~(1UL << 3);
setRelayState(I2C_0_RELAYS_STATE, addr); setRelayState(I2C_0_RELAYS_STATE, addr);
} }
} }
} }
// I2C1 // I2C1
static void afterWriteTimeI2C1_0(UA_Server *server, static void afterWriteTimeI2C1_0(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext, const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeId, void *nodeContext, const UA_NodeId *nodeId, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data) { const UA_NumericRange *range, const UA_DataValue *data)
if (data->value.type == &UA_TYPES[UA_TYPES_INT32]) { {
if (data->value.type == &UA_TYPES[UA_TYPES_INT32])
{
UA_Int32 hrValue = *(UA_Int32 *)data->value.data; UA_Int32 hrValue = *(UA_Int32 *)data->value.data;
int addr = I2C_SLAVE_ADDR_LIST[1]; int addr = I2C_SLAVE_ADDR_LIST[1];
if (hrValue > 0){ if (hrValue > 0)
I2C_1_RELAYS_STATE |= 1UL << 0; {
I2C_1_RELAYS_STATE |= 1UL << 0;
setRelayState(I2C_1_RELAYS_STATE, addr); setRelayState(I2C_1_RELAYS_STATE, addr);
} }
else { else
{
I2C_1_RELAYS_STATE &= ~(1UL << 0); I2C_1_RELAYS_STATE &= ~(1UL << 0);
setRelayState(I2C_1_RELAYS_STATE, addr); setRelayState(I2C_1_RELAYS_STATE, addr);
} }
} }
} }
static void afterWriteTimeI2C1_1(UA_Server *server, static void afterWriteTimeI2C1_1(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext, const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeId, void *nodeContext, const UA_NodeId *nodeId, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data) { const UA_NumericRange *range, const UA_DataValue *data)
if (data->value.type == &UA_TYPES[UA_TYPES_INT32]) { {
if (data->value.type == &UA_TYPES[UA_TYPES_INT32])
{
UA_Int32 hrValue = *(UA_Int32 *)data->value.data; UA_Int32 hrValue = *(UA_Int32 *)data->value.data;
int addr = I2C_SLAVE_ADDR_LIST[1]; int addr = I2C_SLAVE_ADDR_LIST[1];
if (hrValue > 0){ if (hrValue > 0)
I2C_1_RELAYS_STATE |= 1UL << 1; {
I2C_1_RELAYS_STATE |= 1UL << 1;
setRelayState(I2C_1_RELAYS_STATE, addr); setRelayState(I2C_1_RELAYS_STATE, addr);
} }
else { else
{
I2C_1_RELAYS_STATE &= ~(1UL << 1); I2C_1_RELAYS_STATE &= ~(1UL << 1);
setRelayState(I2C_1_RELAYS_STATE, addr); setRelayState(I2C_1_RELAYS_STATE, addr);
} }
} }
} }
static void afterWriteTimeI2C1_2(UA_Server *server, static void afterWriteTimeI2C1_2(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext, const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeId, void *nodeContext, const UA_NodeId *nodeId, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data) { const UA_NumericRange *range, const UA_DataValue *data)
if (data->value.type == &UA_TYPES[UA_TYPES_INT32]) { {
if (data->value.type == &UA_TYPES[UA_TYPES_INT32])
{
UA_Int32 hrValue = *(UA_Int32 *)data->value.data; UA_Int32 hrValue = *(UA_Int32 *)data->value.data;
int addr = I2C_SLAVE_ADDR_LIST[1]; int addr = I2C_SLAVE_ADDR_LIST[1];
if (hrValue > 0){ if (hrValue > 0)
I2C_1_RELAYS_STATE |= 1UL << 2; {
I2C_1_RELAYS_STATE |= 1UL << 2;
setRelayState(I2C_1_RELAYS_STATE, addr); setRelayState(I2C_1_RELAYS_STATE, addr);
} }
else { else
{
I2C_1_RELAYS_STATE &= ~(1UL << 2); I2C_1_RELAYS_STATE &= ~(1UL << 2);
setRelayState(I2C_1_RELAYS_STATE, addr); setRelayState(I2C_1_RELAYS_STATE, addr);
} }
} }
} }
static void afterWriteTimeI2C1_3(UA_Server *server, static void afterWriteTimeI2C1_3(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext, const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeId, void *nodeContext, const UA_NodeId *nodeId, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data) { const UA_NumericRange *range, const UA_DataValue *data)
if (data->value.type == &UA_TYPES[UA_TYPES_INT32]) { {
if (data->value.type == &UA_TYPES[UA_TYPES_INT32])
{
UA_Int32 hrValue = *(UA_Int32 *)data->value.data; UA_Int32 hrValue = *(UA_Int32 *)data->value.data;
int addr = I2C_SLAVE_ADDR_LIST[1]; int addr = I2C_SLAVE_ADDR_LIST[1];
if (hrValue > 0){ if (hrValue > 0)
I2C_1_RELAYS_STATE |= 1UL << 3; {
I2C_1_RELAYS_STATE |= 1UL << 3;
setRelayState(I2C_1_RELAYS_STATE, addr); setRelayState(I2C_1_RELAYS_STATE, addr);
} }
else { else
{
I2C_1_RELAYS_STATE &= ~(1UL << 3); I2C_1_RELAYS_STATE &= ~(1UL << 3);
setRelayState(I2C_1_RELAYS_STATE, addr); setRelayState(I2C_1_RELAYS_STATE, addr);
} }
} }
} }
static void addValueCallbackToCurrentTimeVariable(UA_Server *server)
static void addValueCallbackToCurrentTimeVariable(UA_Server *server) { {
int length = getI2CSlaveListLength(); int length = getI2CSlaveListLength();
// I2C0 // I2C0
// relay 0 // relay 0
UA_NodeId currentNodeId0 = UA_NODEID_STRING(1, "i2c0.relay0"); UA_NodeId currentNodeId0 = UA_NODEID_STRING(1, "i2c0.relay0");
UA_ValueCallback callback0 ; UA_ValueCallback callback0;
callback0.onRead = beforeReadTime; callback0.onRead = beforeReadTime;
callback0.onWrite = afterWriteTimeI2C0_0; callback0.onWrite = afterWriteTimeI2C0_0;
UA_Server_setVariableNode_valueCallback(server, currentNodeId0, callback0); UA_Server_setVariableNode_valueCallback(server, currentNodeId0, callback0);
// relay 1 // relay 1
UA_NodeId currentNodeId1 = UA_NODEID_STRING(1, "i2c0.relay1"); UA_NodeId currentNodeId1 = UA_NODEID_STRING(1, "i2c0.relay1");
UA_ValueCallback callback1 ; UA_ValueCallback callback1;
callback1.onRead = beforeReadTime; callback1.onRead = beforeReadTime;
callback1.onWrite = afterWriteTimeI2C0_1; callback1.onWrite = afterWriteTimeI2C0_1;
UA_Server_setVariableNode_valueCallback(server, currentNodeId1, callback1); UA_Server_setVariableNode_valueCallback(server, currentNodeId1, callback1);
// relay 2 // relay 2
UA_NodeId currentNodeId2 = UA_NODEID_STRING(1, "i2c0.relay2"); UA_NodeId currentNodeId2 = UA_NODEID_STRING(1, "i2c0.relay2");
UA_ValueCallback callback2 ; UA_ValueCallback callback2;
callback2.onRead = beforeReadTime; callback2.onRead = beforeReadTime;
callback2.onWrite = afterWriteTimeI2C0_2; callback2.onWrite = afterWriteTimeI2C0_2;
UA_Server_setVariableNode_valueCallback(server, currentNodeId2, callback2); UA_Server_setVariableNode_valueCallback(server, currentNodeId2, callback2);
// relay 3 // relay 3
UA_NodeId currentNodeId3 = UA_NODEID_STRING(1, "i2c0.relay3"); UA_NodeId currentNodeId3 = UA_NODEID_STRING(1, "i2c0.relay3");
UA_ValueCallback callback3 ; UA_ValueCallback callback3;
callback3.onRead = beforeReadTime; callback3.onRead = beforeReadTime;
callback3.onWrite = afterWriteTimeI2C0_3; callback3.onWrite = afterWriteTimeI2C0_3;
UA_Server_setVariableNode_valueCallback(server, currentNodeId3, callback3); UA_Server_setVariableNode_valueCallback(server, currentNodeId3, callback3);
if(length > 1){ // Digital input 0
UA_NodeId currentNodeId4 = UA_NODEID_STRING(1, "i2c0.in0");
UA_ValueCallback callback4;
callback4.onRead = beforeReadTimeI2C0In0;
callback4.onWrite = afterWriteTime;
UA_Server_setVariableNode_valueCallback(server, currentNodeId4, callback4);
// Digital input 1
UA_NodeId currentNodeId5 = UA_NODEID_STRING(1, "i2c0.in1");
UA_ValueCallback callback5;
callback5.onRead = beforeReadTimeI2C0In1;
callback5.onWrite = afterWriteTime;
UA_Server_setVariableNode_valueCallback(server, currentNodeId5, callback5);
// Digital input 2
UA_NodeId currentNodeId6 = UA_NODEID_STRING(1, "i2c0.in2");
UA_ValueCallback callback6;
callback6.onRead = beforeReadTimeI2C0In2;
callback6.onWrite = afterWriteTime;
UA_Server_setVariableNode_valueCallback(server, currentNodeId6, callback6);
// Digital input 3
UA_NodeId currentNodeId7 = UA_NODEID_STRING(1, "i2c0.in3");
UA_ValueCallback callback7;
callback7.onRead = beforeReadTimeI2C0In3;
callback7.onWrite = afterWriteTime;
UA_Server_setVariableNode_valueCallback(server, currentNodeId7, callback7);
// Analog input 0
UA_NodeId currentNodeId8 = UA_NODEID_STRING(1, "i2c0.ain0");
UA_ValueCallback callback8;
callback8.onRead = beforeReadTimeI2C0Ain0;
callback8.onWrite = afterWriteTime;
UA_Server_setVariableNode_valueCallback(server, currentNodeId8, callback8);
// Analog input 1
UA_NodeId currentNodeId9 = UA_NODEID_STRING(1, "i2c0.ain1");
UA_ValueCallback callback9;
callback9.onRead = beforeReadTimeI2C0Ain1;
callback9.onWrite = afterWriteTime;
UA_Server_setVariableNode_valueCallback(server, currentNodeId9, callback9);
// Analog input 2
UA_NodeId currentNodeId10 = UA_NODEID_STRING(1, "i2c0.ain2");
UA_ValueCallback callback10;
callback10.onRead = beforeReadTimeI2C0Ain2;
callback10.onWrite = afterWriteTime;
UA_Server_setVariableNode_valueCallback(server, currentNodeId10, callback10);
// Analog input 3
UA_NodeId currentNodeId11 = UA_NODEID_STRING(1, "i2c0.ain3");
UA_ValueCallback callback11;
callback11.onRead = beforeReadTimeI2C0Ain3;
callback11.onWrite = afterWriteTime;
UA_Server_setVariableNode_valueCallback(server, currentNodeId11, callback11);
if (length > 1)
{
// I2C1 // I2C1
// relay 0 // relay 0
UA_NodeId currentNodeId4 = UA_NODEID_STRING(1, "i2c1.relay0"); UA_NodeId currentNodeId12 = UA_NODEID_STRING(1, "i2c1.relay0");
UA_ValueCallback callback4; UA_ValueCallback callback12;
callback4.onRead = beforeReadTime; callback12.onRead = beforeReadTime;
callback4.onWrite = afterWriteTimeI2C1_0; callback12.onWrite = afterWriteTimeI2C1_0;
UA_Server_setVariableNode_valueCallback(server, currentNodeId4, callback4); UA_Server_setVariableNode_valueCallback(server, currentNodeId12, callback12);
// relay 1 // relay 1
UA_NodeId currentNodeId5 = UA_NODEID_STRING(1, "i2c1.relay1"); UA_NodeId currentNodeId13 = UA_NODEID_STRING(1, "i2c1.relay1");
UA_ValueCallback callback5; UA_ValueCallback callback13;
callback5.onRead = beforeReadTime; callback13.onRead = beforeReadTime;
callback5.onWrite = afterWriteTimeI2C1_1; callback13.onWrite = afterWriteTimeI2C1_1;
UA_Server_setVariableNode_valueCallback(server, currentNodeId5, callback5); UA_Server_setVariableNode_valueCallback(server, currentNodeId13, callback13);
// relay 2 // relay 2
UA_NodeId currentNodeId6 = UA_NODEID_STRING(1, "i2c1.relay2"); UA_NodeId currentNodeId14 = UA_NODEID_STRING(1, "i2c1.relay2");
UA_ValueCallback callback6; UA_ValueCallback callback14;
callback6.onRead = beforeReadTime; callback14.onRead = beforeReadTime;
callback6.onWrite = afterWriteTimeI2C1_2; callback14.onWrite = afterWriteTimeI2C1_2;
UA_Server_setVariableNode_valueCallback(server, currentNodeId6, callback6); UA_Server_setVariableNode_valueCallback(server, currentNodeId14, callback14);
// relay 2 // relay 2
UA_NodeId currentNodeId7 = UA_NODEID_STRING(1, "i2c1.relay3"); UA_NodeId currentNodeId15 = UA_NODEID_STRING(1, "i2c1.relay3");
UA_ValueCallback callback7; UA_ValueCallback callback15;
callback7.onRead = beforeReadTime; callback15.onRead = beforeReadTime;
callback7.onWrite = afterWriteTimeI2C1_3; callback15.onWrite = afterWriteTimeI2C1_3;
UA_Server_setVariableNode_valueCallback(server, currentNodeId7, callback7); UA_Server_setVariableNode_valueCallback(server, currentNodeId15, callback15);
// Digital input 0
UA_NodeId currentNodeId16 = UA_NODEID_STRING(1, "i2c1.in0");
UA_ValueCallback callback16;
callback16.onRead = beforeReadTimeI2C1In0;
callback16.onWrite = afterWriteTime;
UA_Server_setVariableNode_valueCallback(server, currentNodeId16, callback16);
// Digital input 1
UA_NodeId currentNodeId17 = UA_NODEID_STRING(1, "i2c1.in1");
UA_ValueCallback callback17;
callback17.onRead = beforeReadTimeI2C1In1;
callback17.onWrite = afterWriteTime;
UA_Server_setVariableNode_valueCallback(server, currentNodeId17, callback17);
// Digital input 2
UA_NodeId currentNodeId18 = UA_NODEID_STRING(1, "i2c1.in2");
UA_ValueCallback callback18;
callback18.onRead = beforeReadTimeI2C1In2;
callback18.onWrite = afterWriteTime;
UA_Server_setVariableNode_valueCallback(server, currentNodeId18, callback18);
// Digital input 3
UA_NodeId currentNodeId19 = UA_NODEID_STRING(1, "i2c1.in3");
UA_ValueCallback callback19;
callback19.onRead = beforeReadTimeI2C1In3;
callback19.onWrite = afterWriteTime;
UA_Server_setVariableNode_valueCallback(server, currentNodeId19, callback19);
// Analog input 0
UA_NodeId currentNodeId20 = UA_NODEID_STRING(1, "i2c1.ain0");
UA_ValueCallback callback20;
callback20.onRead = beforeReadTimeI2C1Ain0;
callback20.onWrite = afterWriteTime;
UA_Server_setVariableNode_valueCallback(server, currentNodeId20, callback20);
// Analog input 1
UA_NodeId currentNodeId21 = UA_NODEID_STRING(1, "i2c1.ain1");
UA_ValueCallback callback21;
callback21.onRead = beforeReadTimeI2C1Ain1;
callback21.onWrite = afterWriteTime;
UA_Server_setVariableNode_valueCallback(server, currentNodeId21, callback21);
// Analog input 2
UA_NodeId currentNodeId22 = UA_NODEID_STRING(1, "i2c1.ain2");
UA_ValueCallback callback22;
callback22.onRead = beforeReadTimeI2C1Ain2;
callback22.onWrite = afterWriteTime;
UA_Server_setVariableNode_valueCallback(server, currentNodeId22, callback22);
// Analog input 3
UA_NodeId currentNodeId23 = UA_NODEID_STRING(1, "i2c1.ain3");
UA_ValueCallback callback23;
callback23.onRead = beforeReadTimeI2C1Ain3;
callback23.onWrite = afterWriteTime;
UA_Server_setVariableNode_valueCallback(server, currentNodeId23, callback23);
} }
} }
void safeShutdownI2CSlaveList() { void safeShutdownI2CSlaveList()
{
/* /*
* Perform a safe shutdown of all known I2C slaves * Perform a safe shutdown of all known I2C slaves
*/ */
...@@ -436,24 +1077,27 @@ void safeShutdownI2CSlaveList() { ...@@ -436,24 +1077,27 @@ void safeShutdownI2CSlaveList() {
int addr; int addr;
length = sizeof(I2C_SLAVE_ADDR_LIST) / sizeof(int); length = sizeof(I2C_SLAVE_ADDR_LIST) / sizeof(int);
for(i = 0; i < length; i++) for (i = 0; i < length; i++)
{ {
addr = I2C_SLAVE_ADDR_LIST[i]; addr = I2C_SLAVE_ADDR_LIST[i];
if (addr!= 0) { if (addr != 0)
// properly initialized from CLI {
setRelayState(0x00, addr); // properly initialized from CLI
} setRelayState(0x00, addr);
}
} }
} }
static volatile UA_Boolean running = true; static volatile UA_Boolean running = true;
static void stopHandler(int sign) { static void stopHandler(int sign)
{
UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, "received ctrl-c"); UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, "received ctrl-c");
running = false; running = false;
} }
int main(int argc, char **argv) { int main(int argc, char **argv)
{
int i; int i;
int length; int length;
long result; long result;
...@@ -473,20 +1117,20 @@ int main(int argc, char **argv) { ...@@ -473,20 +1117,20 @@ int main(int argc, char **argv) {
printf("Block device=%s\n", arguments.device); printf("Block device=%s\n", arguments.device);
printf("Slave address list=%s\n", arguments.slave_address_list); printf("Slave address list=%s\n", arguments.slave_address_list);
// transfer to global variables (CLI input) // transfer to global variables (CLI input)
I2C_VIRTUAL_MODE = arguments.mode; I2C_VIRTUAL_MODE = arguments.mode;
I2C_BLOCK_DEVICE_NAME = arguments.device; I2C_BLOCK_DEVICE_NAME = arguments.device;
// convert arguments.slave_address_list -> I2C_SLAVE_ADDR_LIST // convert arguments.slave_address_list -> I2C_SLAVE_ADDR_LIST
i = 0; i = 0;
char *token = strtok(arguments.slave_address_list, ","); char *token = strtok(arguments.slave_address_list, ",");
while (token != NULL) while (token != NULL)
{ {
// from CLI we get a hexidecimal string as a char (0x58 for example), convert to decimal // from CLI we get a hexidecimal string as a char (0x58 for example), convert to decimal
result = strtol(token, &eptr, 16); result = strtol(token, &eptr, 16);
I2C_SLAVE_ADDR_LIST[i++] = result; I2C_SLAVE_ADDR_LIST[i++] = result;
token = strtok (NULL, ","); token = strtok(NULL, ",");
} }
// always start attached slaves from a know safe shutdown state // always start attached slaves from a know safe shutdown state
safeShutdownI2CSlaveList(); safeShutdownI2CSlaveList();
...@@ -496,7 +1140,7 @@ int main(int argc, char **argv) { ...@@ -496,7 +1140,7 @@ int main(int argc, char **argv) {
UA_Server *server = UA_Server_new(); UA_Server *server = UA_Server_new();
UA_ServerConfig_setMinimal(UA_Server_getConfig(server), arguments.port, NULL); UA_ServerConfig_setMinimal(UA_Server_getConfig(server), arguments.port, NULL);
UA_ServerConfig* config = UA_Server_getConfig(server); UA_ServerConfig *config = UA_Server_getConfig(server);
config->verifyRequestTimestamp = UA_RULEHANDLING_ACCEPT; config->verifyRequestTimestamp = UA_RULEHANDLING_ACCEPT;
// add variables representing physical relarys / inputs, etc // add variables representing physical relarys / inputs, etc
...@@ -521,6 +1165,6 @@ int main(int argc, char **argv) { ...@@ -521,6 +1165,6 @@ int main(int argc, char **argv) {
// always leave attached slaves to a known safe shutdown state // always leave attached slaves to a known safe shutdown state
safeShutdownI2CSlaveList(); safeShutdownI2CSlaveList();
return retval == UA_STATUSCODE_GOOD ? EXIT_SUCCESS : EXIT_FAILURE; return retval == UA_STATUSCODE_GOOD ? EXIT_SUCCESS : EXIT_FAILURE;
} }
scripts/beremiz_install.sh
View file @ 3dbb96ce
...@@ -40,7 +40,7 @@ if [[ "$OSTYPE" == "linux-gnu"* ]]; then ...@@ -40,7 +40,7 @@ if [[ "$OSTYPE" == "linux-gnu"* ]]; then
# install required packages # install required packages
apt -yq update apt -yq update
apt -yq install python-wxgtk3.0 python-lxml python-is-python2 python-numpy build-essential python-dev-is-python2 mercurial autoconf bison flex python2 virtualenv python-lxml python-numpy libgtk-3-dev libgl1-mesa-dev libglu1-mesa-dev apt -yq install python-wxgtk3.0 python-lxml python-is-python2 python-numpy build-essential python-dev-is-python2 mercurial autoconf bison flex python2 virtualenv python-lxml python-numpy libgtk-3-dev libgl1-mesa-dev libglu1-mesa-dev
pip2 install pyro twisted nevow autobahn lxml opcua pip2 install pyro twisted nevow autobahn lxml opcua zeroconf==0.19.1
# Path preparation # Path preparation
LOCAL_HOME_DIR=/home/${SUDO_USER:-$(whoami)}/ LOCAL_HOME_DIR=/home/${SUDO_USER:-$(whoami)}/
...@@ -55,19 +55,23 @@ if [[ "$OSTYPE" == "linux-gnu"* ]]; then ...@@ -55,19 +55,23 @@ if [[ "$OSTYPE" == "linux-gnu"* ]]; then
# Build Matiec # Build Matiec
echo "Building Matiec." echo "Building Matiec."
cd $LOCAL_HOME_DIR/Beremiz/
hg clone https://hg.beremiz.org/matiec hg clone https://hg.beremiz.org/matiec
cd matiec/
autoreconf -i autoreconf -i
./configure ./configure
make -j make -j
pwd pwd
# Build Modbus # Build Modbus
echo "Building Modbus." echo "Building Modbus."
cd $LOCAL_HOME_DIR/Beremiz/
hg clone https://hg.beremiz.org/Modbus/ hg clone https://hg.beremiz.org/Modbus/
cd Modbus/
make make
echo "Beremiz is installed." echo "Beremiz is installed."
echo "Run $ python2 ~/Beremiz/Beremiz/Beremiz.py to open Beremiz" echo "Run $ python2 ~/Beremiz/beremiz/Beremiz.py to open Beremiz"
else else
......
scripts/open62541_install.sh 100644 → 100755
View file @ 3dbb96ce
File mode changed from 100644 to 100755
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7