Skip to content

osie
osie
Commit 2d6699e8 authored by Ivan Tyagov's avatar Ivan Tyagov
Browse files
Options

Fixup mod io 

See merge request !40
parents 4e53f19d 0a02dd20
Show whitespace changes
Inline Side-by-side
Showing with 59 additions and 255 deletions
coupler/mod_io_i2c.h
View file @ 2d6699e8
// global relay state // global relay state - XXX: use a list rather than individual variables
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
uint8_t I2C_1_RELAYS_STATE = 0; // state of 4 relays at I2C slave 1 uint8_t I2C_1_RELAYS_STATE = 0; // state of 4 relays at I2C slave 1
...@@ -8,8 +8,11 @@ static char *DEFAULT_I2C_0_ADDR = "0x58"; ...@@ -8,8 +8,11 @@ static char *DEFAULT_I2C_0_ADDR = "0x58";
// the list of attached I2C slaves // the list of attached I2C slaves
const int DEFAULT_I2C_SLAVE_ADDR = 0x58; const int DEFAULT_I2C_SLAVE_ADDR = 0x58;
// XXX:code assumes only 8 I2C slaves but it can be up to 127 // the current architecture of LIME2 supports up to 127 MOD-IO I2C slaves
int I2C_SLAVE_ADDR_LIST[] = {0, 0, 0, 0, 0, 0, 0, 0}; int I2C_SLAVE_ADDR_LIST[127] = {0};
// the number of physical relays
int DEFAULT_RELAY_COUNT = 4;
// the block device at host machine // the block device at host machine
static char *DEFAULT_I2C_BLOCK_DEVICE_NAME = "/dev/i2c-1"; static char *DEFAULT_I2C_BLOCK_DEVICE_NAME = "/dev/i2c-1";
...@@ -173,7 +176,6 @@ static int getAnalogInputStateAIN(int i2c_addr, int **analog_input, uint8_t read ...@@ -173,7 +176,6 @@ static int getAnalogInputStateAIN(int i2c_addr, int **analog_input, uint8_t read
} }
// step 3: write command over I2c // step 3: write command over I2c
//__u8 read_reg = 0x30; /* Device register to access */
char read_buf[10]; char read_buf[10];
read_buf[0] = read_reg; read_buf[0] = read_reg;
if (write(file, read_buf, 1) != 1) if (write(file, read_buf, 1) != 1)
......
coupler/mod_io_opc_ua.h
View file @ 2d6699e8
...@@ -66,138 +66,32 @@ static void addVariable(UA_Server *server) ...@@ -66,138 +66,32 @@ static void addVariable(UA_Server *server)
/* /*
* Create all variables representing MOD-IO's relays * Create all variables representing MOD-IO's relays
*/ */
int i,n;;
int length = getI2CSlaveListLength(); int length = getI2CSlaveListLength();
if (length >= 1) char *node_id = malloc(sizeof(char) * 10);
{ char *node_title = malloc(sizeof(char) * 30);
// IC2-0
addIntegerVariableNode(server, "i2c0.relay0", "I2C0 / Relay 0"); for (i = 0; i < length; i++)
addIntegerVariableNode(server, "i2c0.relay1", "I2C0 / Relay 1"); {
addIntegerVariableNode(server, "i2c0.relay2", "I2C0 / Relay 2"); for (n = 0; n < DEFAULT_RELAY_COUNT; n++)
addIntegerVariableNode(server, "i2c0.relay3", "I2C0 / Relay 3"); {
addBooleanVariableReadNode(server, "i2c0.in0", "I2C0 / Digital Input 0"); // add relay nodes
addBooleanVariableReadNode(server, "i2c0.in1", "I2C0 / Digital Input 1"); sprintf(node_id, "i2c%d.relay%d", i, n);
addBooleanVariableReadNode(server, "i2c0.in2", "I2C0 / Digital Input 2"); sprintf(node_title, "I2C%d / Relay %d", i, n);
addBooleanVariableReadNode(server, "i2c0.in3", "I2C0 / Digital Input 3"); addIntegerVariableNode(server, node_id, node_title);
addUIntegerVariableReadNode(server, "i2c0.ain0", "I2C0 / Analog Input 0"); // add digital in
addUIntegerVariableReadNode(server, "i2c0.ain1", "I2C0 / Analog Input 1"); sprintf(node_id, "i2c%d.in%d", i, n);
addUIntegerVariableReadNode(server, "i2c0.ain2", "I2C0 / Analog Input 2"); sprintf(node_title, "I2C%d / Digital Input %d", i, n);
addUIntegerVariableReadNode(server, "i2c0.ain3", "I2C0 / Analog Input 3"); addBooleanVariableReadNode(server, node_id, node_title);
} // add analog in
if (length >= 2) sprintf(node_id, "i2c%d.ain%d", i, n);
{ sprintf(node_title, "I2C%d / Analog Input %d", i, n);
// IC2-1 addUIntegerVariableReadNode(server, node_id, node_title);
addIntegerVariableNode(server, "i2c1.relay0", "I2C1 / Relay 0"); }
addIntegerVariableNode(server, "i2c1.relay1", "I2C1 / Relay 1"); }
addIntegerVariableNode(server, "i2c1.relay2", "I2C1 / Relay 2"); }
addIntegerVariableNode(server, "i2c1.relay3", "I2C1 / Relay 3");
addBooleanVariableReadNode(server, "i2c1.in0", "I2C1 / Digital Input 0"); /* Connect to variables to physical relays, analog and digital inputs.
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");
}
if (length >= 3)
{
// IC2-2
addIntegerVariableNode(server, "i2c2.relay0", "I2C2 / Relay 0");
addIntegerVariableNode(server, "i2c2.relay1", "I2C2 / Relay 1");
addIntegerVariableNode(server, "i2c2.relay2", "I2C2 / Relay 2");
addIntegerVariableNode(server, "i2c2.relay3", "I2C2 / Relay 3");
addBooleanVariableReadNode(server, "i2c2.in0", "I2C2 / Digital Input 0");
addBooleanVariableReadNode(server, "i2c2.in1", "I2C2 / Digital Input 1");
addBooleanVariableReadNode(server, "i2c2.in2", "I2C2 / Digital Input 2");
addBooleanVariableReadNode(server, "i2c2.in3", "I2C2 / Digital Input 3");
addUIntegerVariableReadNode(server, "i2c2.ain0", "I2C2 / Analog Input 0");
addUIntegerVariableReadNode(server, "i2c2.ain1", "I2C2 / Analog Input 1");
addUIntegerVariableReadNode(server, "i2c2.ain2", "I2C2 / Analog Input 2");
addUIntegerVariableReadNode(server, "i2c2.ain3", "I2C2 / Analog Input 3");
}
if (length >= 4)
{
// IC2-3
addIntegerVariableNode(server, "i2c3.relay0", "I2C3 / Relay 0");
addIntegerVariableNode(server, "i2c3.relay1", "I2C3 / Relay 1");
addIntegerVariableNode(server, "i2c3.relay2", "I2C3 / Relay 2");
addIntegerVariableNode(server, "i2c3.relay3", "I2C3 / Relay 3");
addBooleanVariableReadNode(server, "i2c3.in0", "I2C3 / Digital Input 0");
addBooleanVariableReadNode(server, "i2c3.in1", "I2C3 / Digital Input 1");
addBooleanVariableReadNode(server, "i2c3.in2", "I2C3 / Digital Input 2");
addBooleanVariableReadNode(server, "i2c3.in3", "I2C3 / Digital Input 3");
addUIntegerVariableReadNode(server, "i2c3.ain0", "I2C3 / Analog Input 0");
addUIntegerVariableReadNode(server, "i2c3.ain1", "I2C3 / Analog Input 1");
addUIntegerVariableReadNode(server, "i2c3.ain2", "I2C3 / Analog Input 2");
addUIntegerVariableReadNode(server, "i2c3.ain3", "I2C3 / Analog Input 3");
}
if (length >= 5)
{
// IC2-4
addIntegerVariableNode(server, "i2c4.relay0", "I2C4 / Relay 0");
addIntegerVariableNode(server, "i2c4.relay1", "I2C4 / Relay 1");
addIntegerVariableNode(server, "i2c4.relay2", "I2C4 / Relay 2");
addIntegerVariableNode(server, "i2c4.relay3", "I2C4 / Relay 3");
addBooleanVariableReadNode(server, "i2c4.in0", "I2C4 / Digital Input 0");
addBooleanVariableReadNode(server, "i2c4.in1", "I2C4 / Digital Input 1");
addBooleanVariableReadNode(server, "i2c4.in2", "I2C4 / Digital Input 2");
addBooleanVariableReadNode(server, "i2c4.in3", "I2C4 / Digital Input 3");
addUIntegerVariableReadNode(server, "i2c4.ain0", "I2C4 / Analog Input 0");
addUIntegerVariableReadNode(server, "i2c4.ain1", "I2C4 / Analog Input 1");
addUIntegerVariableReadNode(server, "i2c4.ain2", "I2C4 / Analog Input 2");
addUIntegerVariableReadNode(server, "i2c4.ain3", "I2C4 / Analog Input 3");
}
if (length >= 6)
{
// IC2-5
addIntegerVariableNode(server, "i2c5.relay0", "I2C5 / Relay 0");
addIntegerVariableNode(server, "i2c5.relay1", "I2C5 / Relay 1");
addIntegerVariableNode(server, "i2c5.relay2", "I2C5 / Relay 2");
addIntegerVariableNode(server, "i2c5.relay3", "I2C5 / Relay 3");
addBooleanVariableReadNode(server, "i2c5.in0", "I2C5 / Digital Input 0");
addBooleanVariableReadNode(server, "i2c5.in1", "I2C5 / Digital Input 1");
addBooleanVariableReadNode(server, "i2c5.in2", "I2C5 / Digital Input 2");
addBooleanVariableReadNode(server, "i2c5.in3", "I2C5 / Digital Input 3");
addUIntegerVariableReadNode(server, "i2c5.ain0", "I2C5 / Analog Input 0");
addUIntegerVariableReadNode(server, "i2c5.ain1", "I2C5 / Analog Input 1");
addUIntegerVariableReadNode(server, "i2c5.ain2", "I2C5 / Analog Input 2");
addUIntegerVariableReadNode(server, "i2c5.ain3", "I2C5 / Analog Input 3");
}
if (length >= 7)
{
// IC2-6
addIntegerVariableNode(server, "i2c6.relay0", "I2C6 / Relay 0");
addIntegerVariableNode(server, "i2c6.relay1", "I2C6 / Relay 1");
addIntegerVariableNode(server, "i2c6.relay2", "I2C6 / Relay 2");
addIntegerVariableNode(server, "i2c6.relay3", "I2C6 / Relay 3");
addBooleanVariableReadNode(server, "i2c6.in0", "I2C6 / Digital Input 0");
addBooleanVariableReadNode(server, "i2c6.in1", "I2C6 / Digital Input 1");
addBooleanVariableReadNode(server, "i2c6.in2", "I2C6 / Digital Input 2");
addBooleanVariableReadNode(server, "i2c6.in3", "I2C6 / Digital Input 3");
addUIntegerVariableReadNode(server, "i2c6.ain0", "I2C6 / Analog Input 0");
addUIntegerVariableReadNode(server, "i2c6.ain1", "I2C6 / Analog Input 1");
addUIntegerVariableReadNode(server, "i2c6.ain2", "I2C6 / Analog Input 2");
addUIntegerVariableReadNode(server, "i2c6.ain3", "I2C6 / Analog Input 3");
}
if (length >= 8)
{
// IC2-7
addIntegerVariableNode(server, "i2c7.relay0", "I2C7 / Relay 0");
addIntegerVariableNode(server, "i2c7.relay1", "I2C7 / Relay 1");
addIntegerVariableNode(server, "i2c7.relay2", "I2C7 / Relay 2");
addIntegerVariableNode(server, "i2c7.relay3", "I2C7 / Relay 3");
addBooleanVariableReadNode(server, "i2c7.in0", "I2C7 / Digital Input 0");
addBooleanVariableReadNode(server, "i2c7.in1", "I2C7 / Digital Input 1");
addBooleanVariableReadNode(server, "i2c7.in2", "I2C7 / Digital Input 2");
addBooleanVariableReadNode(server, "i2c7.in3", "I2C7 / Digital Input 3");
addUIntegerVariableReadNode(server, "i2c7.ain0", "I2C7 / Analog Input 0");
addUIntegerVariableReadNode(server, "i2c7.ain1", "I2C7 / Analog Input 1");
addUIntegerVariableReadNode(server, "i2c7.ain2", "I2C7 / Analog Input 2");
addUIntegerVariableReadNode(server, "i2c7.ain3", "I2C7 / Analog Input 3");
}
}
/* Connect to variables to physical relays
* *
*/ */
static void beforeReadTime(UA_Server *server, static void beforeReadTime(UA_Server *server,
...@@ -556,53 +450,45 @@ static void afterWriteTime(UA_Server *server, ...@@ -556,53 +450,45 @@ static void afterWriteTime(UA_Server *server,
// 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 static void setI2CSlaveRelayState(int addr,
// write only one callback function int relay_number,
static void afterWriteTimeI2C0_0(UA_Server *server, uint8_t *global_relays_state,
const UA_NodeId *sessionId, void *sessionContext, const UA_DataValue *data){
const UA_NodeId *nodeId, void *nodeContext, /*
const UA_NumericRange *range, const UA_DataValue *data) * A generic handler function for setting relay state.
{ */
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;
// used only for debuging with logical analyzer // used only for debuging with logical analyzer
if (CURRENT_GPIO_MODE == 2) setGPIO(); if (CURRENT_GPIO_MODE == 2)
setGPIO();
int addr = I2C_SLAVE_ADDR_LIST[0]; if (hrValue > 0){
if (hrValue > 0) *global_relays_state |= 1UL << relay_number;
{ setRelayState(*global_relays_state, addr);
I2C_0_RELAYS_STATE |= 1UL << 0;
setRelayState(I2C_0_RELAYS_STATE, addr);
} }
else else{
{ *global_relays_state &= ~(1UL << relay_number);
I2C_0_RELAYS_STATE &= ~(1UL << 0); setRelayState(*global_relays_state, addr);
setRelayState(I2C_0_RELAYS_STATE, addr);
} }
} }
} }
// I2C0
static void afterWriteTimeI2C0_0(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeId, void *nodeContext,
const UA_NumericRange *range, const UA_DataValue *data)
{
setI2CSlaveRelayState(I2C_SLAVE_ADDR_LIST[0], 0, &I2C_0_RELAYS_STATE, data);
}
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]) setI2CSlaveRelayState(I2C_SLAVE_ADDR_LIST[0], 1, &I2C_0_RELAYS_STATE, data);
{
UA_Int32 hrValue = *(UA_Int32 *)data->value.data;
int addr = I2C_SLAVE_ADDR_LIST[0];
if (hrValue > 0)
{
I2C_0_RELAYS_STATE |= 1UL << 1;
setRelayState(I2C_0_RELAYS_STATE, addr);
}
else
{
I2C_0_RELAYS_STATE &= ~(1UL << 1);
setRelayState(I2C_0_RELAYS_STATE, addr);
}
}
} }
static void afterWriteTimeI2C0_2(UA_Server *server, static void afterWriteTimeI2C0_2(UA_Server *server,
...@@ -610,21 +496,7 @@ static void afterWriteTimeI2C0_2(UA_Server *server, ...@@ -610,21 +496,7 @@ static void afterWriteTimeI2C0_2(UA_Server *server,
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]) setI2CSlaveRelayState(I2C_SLAVE_ADDR_LIST[0], 2, &I2C_0_RELAYS_STATE, data);
{
UA_Int32 hrValue = *(UA_Int32 *)data->value.data;
int addr = I2C_SLAVE_ADDR_LIST[0];
if (hrValue > 0)
{
I2C_0_RELAYS_STATE |= 1UL << 2;
setRelayState(I2C_0_RELAYS_STATE, addr);
}
else
{
I2C_0_RELAYS_STATE &= ~(1UL << 2);
setRelayState(I2C_0_RELAYS_STATE, addr);
}
}
} }
static void afterWriteTimeI2C0_3(UA_Server *server, static void afterWriteTimeI2C0_3(UA_Server *server,
...@@ -632,21 +504,7 @@ static void afterWriteTimeI2C0_3(UA_Server *server, ...@@ -632,21 +504,7 @@ static void afterWriteTimeI2C0_3(UA_Server *server,
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]) setI2CSlaveRelayState(I2C_SLAVE_ADDR_LIST[0], 3, &I2C_0_RELAYS_STATE, data);
{
UA_Int32 hrValue = *(UA_Int32 *)data->value.data;
int addr = I2C_SLAVE_ADDR_LIST[0];
if (hrValue > 0)
{
I2C_0_RELAYS_STATE |= 1UL << 3;
setRelayState(I2C_0_RELAYS_STATE, addr);
}
else
{
I2C_0_RELAYS_STATE &= ~(1UL << 3);
setRelayState(I2C_0_RELAYS_STATE, addr);
}
}
} }
// I2C1 // I2C1
...@@ -655,21 +513,7 @@ static void afterWriteTimeI2C1_0(UA_Server *server, ...@@ -655,21 +513,7 @@ static void afterWriteTimeI2C1_0(UA_Server *server,
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]) setI2CSlaveRelayState(I2C_SLAVE_ADDR_LIST[1], 0, &I2C_1_RELAYS_STATE, data);
{
UA_Int32 hrValue = *(UA_Int32 *)data->value.data;
int addr = I2C_SLAVE_ADDR_LIST[1];
if (hrValue > 0)
{
I2C_1_RELAYS_STATE |= 1UL << 0;
setRelayState(I2C_1_RELAYS_STATE, addr);
}
else
{
I2C_1_RELAYS_STATE &= ~(1UL << 0);
setRelayState(I2C_1_RELAYS_STATE, addr);
}
}
} }
static void afterWriteTimeI2C1_1(UA_Server *server, static void afterWriteTimeI2C1_1(UA_Server *server,
...@@ -677,21 +521,7 @@ static void afterWriteTimeI2C1_1(UA_Server *server, ...@@ -677,21 +521,7 @@ static void afterWriteTimeI2C1_1(UA_Server *server,
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]) setI2CSlaveRelayState(I2C_SLAVE_ADDR_LIST[1], 1, &I2C_1_RELAYS_STATE, data);
{
UA_Int32 hrValue = *(UA_Int32 *)data->value.data;
int addr = I2C_SLAVE_ADDR_LIST[1];
if (hrValue > 0)
{
I2C_1_RELAYS_STATE |= 1UL << 1;
setRelayState(I2C_1_RELAYS_STATE, addr);
}
else
{
I2C_1_RELAYS_STATE &= ~(1UL << 1);
setRelayState(I2C_1_RELAYS_STATE, addr);
}
}
} }
static void afterWriteTimeI2C1_2(UA_Server *server, static void afterWriteTimeI2C1_2(UA_Server *server,
...@@ -699,21 +529,7 @@ static void afterWriteTimeI2C1_2(UA_Server *server, ...@@ -699,21 +529,7 @@ static void afterWriteTimeI2C1_2(UA_Server *server,
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]) setI2CSlaveRelayState(I2C_SLAVE_ADDR_LIST[1], 2, &I2C_1_RELAYS_STATE, data);
{
UA_Int32 hrValue = *(UA_Int32 *)data->value.data;
int addr = I2C_SLAVE_ADDR_LIST[1];
if (hrValue > 0)
{
I2C_1_RELAYS_STATE |= 1UL << 2;
setRelayState(I2C_1_RELAYS_STATE, addr);
}
else
{
I2C_1_RELAYS_STATE &= ~(1UL << 2);
setRelayState(I2C_1_RELAYS_STATE, addr);
}
}
} }
static void afterWriteTimeI2C1_3(UA_Server *server, static void afterWriteTimeI2C1_3(UA_Server *server,
...@@ -721,21 +537,7 @@ static void afterWriteTimeI2C1_3(UA_Server *server, ...@@ -721,21 +537,7 @@ static void afterWriteTimeI2C1_3(UA_Server *server,
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]) setI2CSlaveRelayState(I2C_SLAVE_ADDR_LIST[1], 3, &I2C_1_RELAYS_STATE, data);
{
UA_Int32 hrValue = *(UA_Int32 *)data->value.data;
int addr = I2C_SLAVE_ADDR_LIST[1];
if (hrValue > 0)
{
I2C_1_RELAYS_STATE |= 1UL << 3;
setRelayState(I2C_1_RELAYS_STATE, addr);
}
else
{
I2C_1_RELAYS_STATE &= ~(1UL << 3);
setRelayState(I2C_1_RELAYS_STATE, addr);
}
}
} }
static void addValueCallbackToCurrentTimeVariable(UA_Server *server) static void addValueCallbackToCurrentTimeVariable(UA_Server *server)
......
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