561 lines
27 KiB
Plaintext
561 lines
27 KiB
Plaintext
/*@!Encoding:1252*/
|
|
includes
|
|
{
|
|
#include "include/DeviceInformation.cin"
|
|
#include "include/ModbusUdp.cin"
|
|
#include "include/ModbusClient.cin"
|
|
}
|
|
|
|
variables
|
|
{
|
|
char[16] gIps[long]; // List of IP addresses. These will be analysed
|
|
char gScanFirstIp[16]; // The first IP address that will be scanned
|
|
char gScanLastIp[16]; // The first IP address that will be scanned
|
|
byte skip255; // Whether the IP address .255 (broadcast in /24 nets) shall be skipped
|
|
|
|
char fnSysvar[100]; // Filename of Sysvars
|
|
char fnDbc[100]; // Filename of DBC
|
|
dword ips[50]; // detected IPs. We need this array for enumeration with integers (assoc. arrays cannot be enumerated with integers :( )
|
|
|
|
|
|
file f; // The file we are writing to
|
|
struct device gIpsSorted[long]; // The final array with the devices
|
|
dword gScanCurr, gScanLast; // The first and last IP address as dword
|
|
word ADi, ADn, ADl; // Some variables for AnalyzeDevices() (event driven, so global)
|
|
|
|
byte ggMaxTransmissionCount; // temp var for gMaxTransmissionCount
|
|
|
|
enum eNodeName {WholeIp, LastByte, TwoLastBytes, ThreeLastBytes};
|
|
enum eNodeName NodeNameStyle; // The style of the node name
|
|
}
|
|
|
|
on preStart
|
|
{
|
|
byte i = 0;
|
|
// List of IPs of devices goes here
|
|
///strncpy(gIps[i++], "192.168.1.100", elCount(gIps));
|
|
///strncpy(gIps[i++], "192.168.1.101", elCount(gIps));
|
|
|
|
// Scan a range of IPs for devices (if nothing was set above). Start and Stop go here
|
|
strncpy(gScanFirstIp, "192.168.1.2", elCount(gScanFirstIp));
|
|
strncpy(gScanLastIp, "192.168.1.255", elCount(gScanLastIp));
|
|
|
|
// How the Node name shall be formatted
|
|
// LastByte: 192.168.12.34 --> Client_34
|
|
// TwoLastBytes: 192.168.12.34 --> Client_12_34
|
|
// ThreeLastBytes: 192.168.12.34 --> Client_168_12_34
|
|
// WholeIp: 192.168.12.34 --> Client_192_168_12_34
|
|
NodeNameStyle = LastByte;
|
|
// Whether the IP address .255 (broadcast in /24) shall be skipped
|
|
skip255 = 1;
|
|
|
|
// Paths to the generated files relative to MakeConfig.cfg
|
|
strncpy(fnSysvar, "include/SysVars/Modbus.vsysvar", elCount(fnSysvar));
|
|
strncpy(fnDbc, "include/DBC/Modbus.dbc", elCount(fnDbc));
|
|
|
|
OutputDebugLevel = Error;
|
|
}
|
|
|
|
on start
|
|
{
|
|
ggMaxTransmissionCount = @sysvar::Config::Modbus::MaxTransmissionCount; // save the value
|
|
|
|
DeviceInit(All);
|
|
if (gIps.Size() == 0) // if no IP address were specified
|
|
DetectDevices(); // scan network for devices (Step1)
|
|
else
|
|
MakeIpNets(); // else continue with Step2
|
|
}
|
|
|
|
/// <PutString>
|
|
void PutString(char str[])
|
|
{
|
|
f.PutString(str, strlen(str));
|
|
}
|
|
/// <PutString>
|
|
void PutString(word d)
|
|
{
|
|
char str[6];
|
|
ltoa(d, str, 10);
|
|
f.PutString(str, strlen(str));
|
|
}
|
|
/// <PutString>
|
|
void PutString(byte d)
|
|
{
|
|
char str[4];
|
|
ltoa(d, str, 10);
|
|
f.PutString(str, strlen(str));
|
|
}
|
|
|
|
// Step 1: Detect active devices and collect IP addresses
|
|
// This function will convert the IP address, open the socket and start the detection. The rest will be done by events
|
|
/// <Step1>
|
|
void DetectDevices()
|
|
{
|
|
writeLineEx(0, 1, "Scanning from %s to %s with timeout of %d ms", gScanFirstIp, gScanLastIp, @sysvar::Config::Modbus::RequestTimeout);
|
|
|
|
gScanCurr = ipGetAddressAsNumber(gScanFirstIp); // We have to use big endian here
|
|
gScanLast = swapDWord(ipGetAddressAsNumber(gScanLastIp)); // But not here :)
|
|
|
|
writeLineEx(0, 0, "%d.%d.%d.%d ", gScanCurr & 0xFF, (gScanCurr >> 8) & 0xFF, (gScanCurr >> 16) & 0xFF, gScanCurr >> 24);
|
|
ModbusInit(gScanFirstIp, @sysvar::Config::Modbus::Port, @sysvar::Config::Modbus::RequestTimeout, 1); // Open socket and set variables
|
|
ModbusReadBits(0, 1); // Start device detection
|
|
}
|
|
// This function will increment the IP address and continue the detection
|
|
/// <Step1>
|
|
void DetectDevicesNext()
|
|
{
|
|
gScanCurr = swapDWord(gScanCurr); // Swap to increment
|
|
gScanCurr++; // Increment
|
|
if ((gScanCurr & 0xFF) == 0xFF) // If .255
|
|
{
|
|
if (skip255) // If we shall skip .255
|
|
gScanCurr++;
|
|
writeLineEx(0, 0, "%d.%d.%d.%d ", gScanCurr >> 24, (gScanCurr >> 16) & 0xFF, (gScanCurr >> 8) & 0xFF, gScanCurr & 0xFF);
|
|
}
|
|
|
|
if (gScanCurr > gScanLast) // If we are beyond the last ip address
|
|
{
|
|
@sysvar::Config::Modbus::MaxTransmissionCount = ggMaxTransmissionCount; // reset
|
|
MakeIpNets(); // Continue with Step 2
|
|
return;
|
|
}
|
|
|
|
gScanCurr = swapDWord(gScanCurr); // Swap back
|
|
|
|
writeEx(0, 0, "."); // Write something so the user knows something is happening
|
|
gRemoteIP = gScanCurr; // Don't open new socket, it takes too much time. This means we should use UDP or EIL here!
|
|
ModbusReadBits(0, 1); // Scan the next device
|
|
}
|
|
/// <Step1>
|
|
void OnModbusReadBitsFailed(enum ModbusRequestError error, enum ModbusException ex, struct ModbusApHeader mbap)
|
|
{
|
|
DetectDevicesNext(); // Timeout, NotSent or Exception! We will go to the next device
|
|
}
|
|
/// <Step1>
|
|
void OnModbusReadBitsSuccess(struct ModbusResReceiveBits mbres, byte bitStatus[], struct ModbusReqRead mbreq)
|
|
{
|
|
ipGetAddressAsString(gScanCurr, gIps[gScanCurr], 16); // store the detected device's IP address
|
|
DetectDevicesNext(); // and continue
|
|
}
|
|
|
|
|
|
// Step 2: Sort into subnets and create structure
|
|
// Sort the IPs from gIps to gIpsSorted
|
|
/// <Step2>
|
|
void MakeIpNets()
|
|
{
|
|
long ipNum;
|
|
|
|
if (gIps.Size() == 0) // If no devices were specified and detected
|
|
{
|
|
writeDbg(MbError, "No devices found!");
|
|
stop(); // Don't do anything
|
|
return;
|
|
}
|
|
|
|
for (long i : gIps) // Iterate all devices
|
|
{
|
|
ipNum = ipGetAddressAsNumber(gIps[i]); // convert IP to dword
|
|
|
|
ips[gIpsSorted.size()] = ipNum; // add ip address to normal array
|
|
// fill the device structure array:
|
|
strncpy(gIpsSorted[ipNum].IP, gIps[i], 16); // set .IP
|
|
ltoa((ipNum ) & 0xFF, gIpsSorted[ipNum].Ip1, 10); // set .Ip1
|
|
ltoa((ipNum >> 8) & 0xFF, gIpsSorted[ipNum].Ip2, 10); // set .Ip2
|
|
ltoa((ipNum >> 16) & 0xFF, gIpsSorted[ipNum].Ip3, 10); // set .Ip3
|
|
ltoa((ipNum >> 24) & 0xFF, gIpsSorted[ipNum].Ip4, 10); // set .Ip4
|
|
|
|
gIps.Remove(i);
|
|
}
|
|
|
|
AnalyzeDevices(); // Continue with step 3
|
|
}
|
|
|
|
|
|
// Step 3: Retreive configuration of devices
|
|
/// <Step3>
|
|
void AnalyzeDevices()
|
|
{
|
|
// Init counters
|
|
ADn = 1; // expect 1 response
|
|
ADi = 0; // First IP address
|
|
ADl = gIpsSorted.Size();
|
|
|
|
writeLineEx(0, 1, "Analyzing %s", gIpsSorted[ips[ADi]].Ip);
|
|
|
|
if (gRemoteIP != INVALID_IP) // If we already do have a socket
|
|
gRemoteIP = ips[ADi]; // use it
|
|
else // else create a new one
|
|
_ModbusConnectTo(ips[ADi], @sysvar::Config::Modbus::Port);
|
|
|
|
// request something special to get the vendor
|
|
// since there is no common register that holds the vendor
|
|
// we have to send a request that only one device responds correctly.
|
|
// At 0x1000-0x1002 B&R devices return the MAC address, whereas Wago holds the WatchdogTime.
|
|
// As the watchdog time only consists of 1 word Wago will return a IllegalDataAddress exception (0x02)
|
|
ModbusReadRegisters(0x1000, 3); // Request B&R MAC address
|
|
}
|
|
/// <Step3>
|
|
void AnalyzeDevicesNext()
|
|
{
|
|
// clean up the string of the previous devices
|
|
if (strlen(gIpsSorted[ips[ADi]].DeviceIOs.Modules) > 0) // If we do have some Modules in this string
|
|
gIpsSorted[ips[ADi]].DeviceIOs.Modules[strlen(gIpsSorted[ips[ADi]].DeviceIOs.Modules)-1] = 0; // Remove the last comma (set the char to NUL)
|
|
// print the result
|
|
writeEx(0, 1, ": AOs: %d, AIs: %d, DOs: %d, DIs: %d --> %s", gIpsSorted[ips[ADi]].DeviceIOs.OutputRegisters, gIpsSorted[ips[ADi]].DeviceIOs.InputRegisters, gIpsSorted[ips[ADi]].DeviceIOs.OutputBits, gIpsSorted[ips[ADi]].DeviceIOs.InputBits, gIpsSorted[ips[ADi]].DeviceIOs.Modules);
|
|
|
|
if (++ADi >= ADl) // continue with the next device. If we have analyzed all devices
|
|
{
|
|
MakeFiles(); // go to Step4
|
|
return;
|
|
}
|
|
|
|
ADn = 1; // expect 1 response again
|
|
gRemoteIP = ips[ADi]; // Next IP address
|
|
writeLineEx(0, 1, "Analyzing %s", gIpsSorted[ips[ADi]].Ip);
|
|
// request something special to get the vendor
|
|
ModbusReadRegisters(0x1000, 3); // Request B&R MAC address
|
|
}
|
|
/// <Step3>
|
|
void OnModbusReadRegistersFailed(enum ModbusRequestError error, enum ModbusException ex, struct ModbusApHeader mbap)
|
|
{
|
|
struct ModbusReqRead mbreq;
|
|
|
|
switch (error)
|
|
{
|
|
case Exception:
|
|
memcpy_n2h(mbreq, gQueueAck[mbap.TxID].Buffer);
|
|
|
|
if (mbreq.Address == 0x1000 && ex == IllegalDataAddress) // We requested B&R MAC and it didn't work --> Not B&R --> Wago. Not future proof :(
|
|
{
|
|
gIpsSorted[ips[ADi]].Vendor = Wago;
|
|
// request information
|
|
ADn = _DeviceGetInformation(Wago);
|
|
return;
|
|
}
|
|
|
|
writeLineEx(0, 3, "Error while analyzing %s! The device respond with exception code %d! Ignoring...", gIpsSorted[ips[ADi]].IP, ex);
|
|
break;
|
|
case Timeout:
|
|
return; // Timeout is unimportant, it means the request will be resent
|
|
case FinalTimeout:
|
|
writeLineEx(0, 3, "Error while analyzing %s! The device did not respond! Ignoring...", gIpsSorted[ips[ADi]].IP);
|
|
break;
|
|
case NotSent:
|
|
writeLineEx(0, 3, "Error while analyzing %s! The device was not available! Ignoring...", gIpsSorted[ips[ADi]].IP);
|
|
break;
|
|
default:
|
|
writeLineEx(0, 3, "OnModbusReadRegistersFailed: Unknown error: %d", error);
|
|
OnModbusClientPanics(SwitchArgumentInvalid);
|
|
return;
|
|
}
|
|
gQueueAck.Clear(); // Clear all queues
|
|
gQueuePending.Clear();
|
|
gQueueSent.Clear();
|
|
gIpsSorted.Remove(ips[ADi]); // Remove the IP
|
|
AnalyzeDevicesNext(); // And go to the next device
|
|
}
|
|
/// <Step3>
|
|
void OnModbusReadRegistersSuccess(struct ModbusResReceiveRegisters mbres, struct ModbusReqRead mbreq)
|
|
{
|
|
if (mbreq.Address == 0x1000) // We detected a B&R device (from MAC address)
|
|
{
|
|
gIpsSorted[ips[ADi]].Vendor = BuR;
|
|
|
|
// request further information
|
|
ADn = _DeviceGetInformation(BuR);
|
|
return;
|
|
}
|
|
|
|
// else parse the received data
|
|
_DeviceParseRegister(gIpsSorted[ips[ADi]], mbreq.Address, mbres.Data, mbreq.Count);
|
|
|
|
if (--ADn == 0) // If we received all registers
|
|
AnalyzeDevicesNext(); // Continue with the next device
|
|
}
|
|
|
|
// Step 4: Create the files with the queried data
|
|
/// <Step4>
|
|
void MakeFiles()
|
|
{
|
|
GenSysvars();
|
|
GenDbc();
|
|
stop();
|
|
}
|
|
|
|
// Generate the SysVars XML
|
|
/// <Step4>
|
|
void GenSysvars()
|
|
{
|
|
writeLineEx(0, 1, "GenSysvars() -> %s", fnSysvar);
|
|
f.Open(fnSysvar, 0, 0); // rewrite file in ASCII
|
|
|
|
PutString("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
|
|
PutString("<systemvariables version=\"4\">\n");
|
|
|
|
PutString(" <namespace name=\"Config\" comment=\"\">\n");
|
|
PutString(" <namespace name=\"Modbus\" comment=\"\">\n");
|
|
PutString(" <variable anlyzLocal=\"2\" readOnly=\"false\" valueSequence=\"false\" unit=\"ms\" name=\"RequestTimeout\" comment=\"The maximum duration for a Modbus-UDP/-TCP request in milliseconds. After timeout a retransmission may be started (see MaxRetransmissionCount). Use `ping` to get the maximum latency to a device, double it and add 2-3 ms for processing.\" bitcount=\"32\" isSigned=\"true\" encoding=\"65001\" type=\"int\" startValue=\"");
|
|
PutString((word)@sysvar::Config::Modbus::RequestTimeout);
|
|
PutString("\" minValue=\"1\" minValuePhys=\"1\" maxValue=\"1000\" maxValuePhys=\"1000\" />\n");
|
|
PutString(" <variable anlyzLocal=\"2\" readOnly=\"false\" valueSequence=\"false\" unit=\"\" name=\"Port\" comment=\"\" bitcount=\"32\" isSigned=\"true\" encoding=\"65001\" type=\"int\" startValue=\"");
|
|
PutString((word)@sysvar::Config::Modbus::Port);
|
|
PutString("\" minValue=\"1\" minValuePhys=\"1\" maxValue=\"65535\" maxValuePhys=\"65535\" />\n");
|
|
PutString(" <variable anlyzLocal=\"2\" readOnly=\"false\" valueSequence=\"false\" unit=\"times\" name=\"MaxTransmissionCount\" comment=\"How often a retransmission of a request will be sent until it gets discarded and an error is thrown.\" bitcount=\"32\" isSigned=\"true\" encoding=\"65001\" type=\"int\" startValue=\"");
|
|
PutString((byte)@sysvar::Config::Modbus::MaxTransmissionCount);
|
|
PutString("\" minValue=\"1\" minValuePhys=\"1\" maxValue=\"10\" maxValuePhys=\"10\" />\n");
|
|
PutString(" </namespace>\n");
|
|
PutString(" <namespace name=\"TcpIp\" comment=\"\">\n");
|
|
PutString(" <variable anlyzLocal=\"2\" readOnly=\"false\" valueSequence=\"false\" unit=\"\" name=\"AdapterIndex\" comment=\"Index of network interface to use\" bitcount=\"32\" isSigned=\"true\" encoding=\"65001\" type=\"int\" startValue=\"2\" minValue=\"1\" minValuePhys=\"1\" maxValue=\"20\" maxValuePhys=\"20\" />\n");
|
|
PutString(" </namespace>\n");
|
|
PutString(" </namespace>\n");
|
|
|
|
PutString(" <namespace name=\"Modbus\" comment=\"\">\n");
|
|
|
|
for (long ipN : gIpsSorted)
|
|
{
|
|
DeviceInit(gIpsSorted[ipN].Vendor);
|
|
|
|
PutString(" <namespace name=\"Client_");
|
|
switch (NodeNameStyle) // Add the IP bytes depending on the style. Don't break anywhere.
|
|
{
|
|
case WholeIp:
|
|
PutString(gIpsSorted[ipN].Ip1);
|
|
PutString("_");
|
|
case ThreeLastBytes:
|
|
PutString(gIpsSorted[ipN].Ip2);
|
|
PutString("_");
|
|
case TwoLastBytes:
|
|
PutString(gIpsSorted[ipN].Ip3);
|
|
PutString("_");
|
|
case LastByte:
|
|
PutString(gIpsSorted[ipN].Ip4);
|
|
break;
|
|
default:
|
|
writeDbg(MbError, "The NodeNameStyle %d is unknown, please use a value of the enum!", NodeNameStyle);
|
|
runError(1001, 0);
|
|
return;
|
|
}
|
|
PutString("\" comment=\"Server with ip address '");
|
|
PutString(gIpsSorted[ipN].Ip);
|
|
PutString("'\">\n");
|
|
|
|
// Namespace Config
|
|
PutString(" <namespace name=\"Config\" comment=\"Configuration section for this server\">\n");
|
|
// IP
|
|
PutString(" <variable anlyzLocal=\"2\" readOnly=\"false\" valueSequence=\"false\" unit=\"\" name=\"IP\" comment=\"The IP address of this server\" bitcount=\"8\" isSigned=\"true\" encoding=\"65001\" type=\"string\" startValue=\"");
|
|
PutString(gIpsSorted[ipN].Ip);
|
|
PutString("\" />\n");
|
|
// Intveral
|
|
PutString(" <variable anlyzLocal=\"2\" readOnly=\"false\" valueSequence=\"false\" unit=\"ms\" name=\"Interval\" comment=\"The interval with which the device will be queried\" bitcount=\"32\" isSigned=\"true\" encoding=\"65001\" type=\"int\" startValue=\"100\" minValue=\"10\" minValuePhys=\"10\" maxValue=\"10000\" maxValuePhys=\"10000\" />\n");
|
|
PutString(" </namespace>\n");
|
|
|
|
//Namespace Info
|
|
PutString(" <namespace name=\"Info\" comment=\"Some information about the device\">\n");
|
|
// Vendor
|
|
PutString(" <variable anlyzLocal=\"2\" readOnly=\"true\" valueSequence=\"false\" unit=\"\" name=\"Vendor\" comment=\"The vendor of the device\" bitcount=\"32\" isSigned=\"true\" encoding=\"65001\" type=\"int\" startValue=\"");
|
|
PutString((byte)gIpsSorted[ipN].Vendor);
|
|
PutString("\">\n");
|
|
PutString(" <valuetable definesMinMax=\"true\">\n");
|
|
PutString(" <valuetableentry value=\"2\" description=\"BuR\" />\n");
|
|
PutString(" <valuetableentry value=\"23\" description=\"Wago\" />\n");
|
|
PutString(" </valuetable>\n");
|
|
PutString(" </variable>\n");
|
|
// SerialCode
|
|
PutString(" <variable anlyzLocal=\"2\" readOnly=\"true\" valueSequence=\"false\" unit=\"\" name=\"SerialCode\" comment=\"The serial code of the server\" bitcount=\"32\" isSigned=\"true\" encoding=\"65001\" type=\"int\" startValue=\"");
|
|
PutString(gIpsSorted[ipN].SerialCode);
|
|
PutString("\" minValue=\"1\" minValuePhys=\"1\" maxValue=\"10000\" maxValuePhys=\"10000\" />\n");
|
|
// DeviceCode
|
|
PutString(" <variable anlyzLocal=\"2\" readOnly=\"true\" valueSequence=\"false\" unit=\"\" name=\"DeviceCode\" comment=\"The device code of the server\" bitcount=\"32\" isSigned=\"true\" encoding=\"65001\" type=\"int\" startValue=\"");
|
|
PutString(gIpsSorted[ipN].DeviceCode);
|
|
PutString("\" minValue=\"1\" minValuePhys=\"1\" maxValue=\"10000\" maxValuePhys=\"10000\" />\n");
|
|
// Modules
|
|
PutString(" <variable anlyzLocal=\"2\" readOnly=\"true\" valueSequence=\"false\" unit=\"\" name=\"Modules\" comment=\"The type and number of inputs of modules that are connected to the server\" bitcount=\"8\" isSigned=\"true\" encoding=\"65001\" type=\"string\" startValue=\"");
|
|
PutString(gIpsSorted[ipN].DeviceIOs.Modules);
|
|
PutString("\" />\n");
|
|
// InputRegisters
|
|
PutString(" <variable anlyzLocal=\"2\" readOnly=\"true\" valueSequence=\"false\" unit=\"\" name=\"InputRegisters\" comment=\"Number of input registers\" bitcount=\"32\" isSigned=\"true\" encoding=\"65001\" type=\"int\" startValue=\"");
|
|
PutString(gIpsSorted[ipN].DeviceIOs.InputRegisters);
|
|
PutString("\" minValue=\"0\" minValuePhys=\"0\" maxValue=\"");
|
|
PutString((word)thisDev.MaxRegisterCount);
|
|
PutString("\" maxValuePhys=\"");
|
|
PutString((word)thisDev.MaxRegisterCount);
|
|
PutString("\" />\n");
|
|
// InputBits
|
|
PutString(" <variable anlyzLocal=\"2\" readOnly=\"true\" valueSequence=\"false\" unit=\"\" name=\"InputBits\" comment=\"Number of input bits\" bitcount=\"32\" isSigned=\"true\" encoding=\"65001\" type=\"int\" startValue=\"");
|
|
PutString(gIpsSorted[ipN].DeviceIOs.InputBits);
|
|
PutString("\" minValue=\"0\" minValuePhys=\"0\" maxValue=\"");
|
|
PutString((word)thisDev.MaxBitCount);
|
|
PutString("\" maxValuePhys=\"");
|
|
PutString((word)thisDev.MaxBitCount);
|
|
PutString("\" />\n");
|
|
// OutputRegisters
|
|
PutString(" <variable anlyzLocal=\"2\" readOnly=\"true\" valueSequence=\"false\" unit=\"\" name=\"OutputRegisters\" comment=\"Number of output registers\" bitcount=\"32\" isSigned=\"true\" encoding=\"65001\" type=\"int\" startValue=\"");
|
|
PutString(gIpsSorted[ipN].DeviceIOs.OutputRegisters);
|
|
PutString("\" minValue=\"0\" minValuePhys=\"0\" maxValue=\"");
|
|
PutString((word)thisDev.MaxRegisterCount);
|
|
PutString("\" maxValuePhys=\"");
|
|
PutString((word)thisDev.MaxRegisterCount);
|
|
PutString("\" />\n");
|
|
// OutputBits
|
|
PutString(" <variable anlyzLocal=\"2\" readOnly=\"true\" valueSequence=\"false\" unit=\"\" name=\"OutputBits\" comment=\"Number of output bits\" bitcount=\"32\" isSigned=\"true\" encoding=\"65001\" type=\"int\" startValue=\"");
|
|
PutString(gIpsSorted[ipN].DeviceIOs.OutputBits);
|
|
PutString("\" minValue=\"0\" minValuePhys=\"0\" maxValue=\"");
|
|
PutString((word)thisDev.MaxBitCount);
|
|
PutString("\" maxValuePhys=\"");
|
|
PutString((word)thisDev.MaxBitCount);
|
|
PutString("\" />\n");
|
|
PutString(" </namespace>\n");
|
|
|
|
// Namespace Data
|
|
PutString(" <namespace name=\"Data\" comment=\"The actual process image\">\n");
|
|
// InputRegisters
|
|
PutString(" <variable anlyzLocal=\"2\" readOnly=\"false\" valueSequence=\"false\" unit=\"\" name=\"InputRegisters\" comment=\"The values of the input registers\" bitcount=\"17\" isSigned=\"true\" encoding=\"65001\" type=\"intarray\" arrayLength=\"");
|
|
PutString(gIpsSorted[ipN].DeviceIOs.InputRegisters);
|
|
PutString("\" />\n");
|
|
// InputBits
|
|
PutString(" <variable anlyzLocal=\"2\" readOnly=\"false\" valueSequence=\"false\" unit=\"\" name=\"InputBits\" comment=\"The state of the input bits\" bitcount=\"2\" isSigned=\"true\" encoding=\"65001\" type=\"intarray\" arrayLength=\"");
|
|
PutString(gIpsSorted[ipN].DeviceIOs.InputBits);
|
|
PutString("\" />\n");
|
|
// OutputRegisters
|
|
PutString(" <variable anlyzLocal=\"2\" readOnly=\"false\" valueSequence=\"false\" unit=\"\" name=\"OutputRegisters\" comment=\"The values of the output registers. Write here and the values will be sent to the device\" bitcount=\"17\" isSigned=\"true\" encoding=\"65001\" type=\"intarray\" arrayLength=\"");
|
|
PutString(gIpsSorted[ipN].DeviceIOs.OutputRegisters);
|
|
PutString("\" />\n");
|
|
// OutputBits
|
|
PutString(" <variable anlyzLocal=\"2\" readOnly=\"false\" valueSequence=\"false\" unit=\"\" name=\"OutputBits\" comment=\"The state of the output bits. Write here and the values will be sent to the device\" bitcount=\"2\" isSigned=\"true\" encoding=\"65001\" type=\"intarray\" arrayLength=\"");
|
|
PutString(gIpsSorted[ipN].DeviceIOs.OutputBits);
|
|
PutString("\" />\n");
|
|
|
|
PutString(" </namespace>\n");
|
|
PutString(" </namespace>\n");
|
|
}
|
|
|
|
PutString(" </namespace>\n");
|
|
PutString("</systemvariables>\n");
|
|
|
|
f.Close();
|
|
}
|
|
|
|
// Generate the Database
|
|
/// <Step4>
|
|
void GenDbc()
|
|
{
|
|
writeLineEx(0, 1, "GenDbc() -> %s", fnDbc);
|
|
f.Open(fnDbc, 0, 0); // rewrite file in ASCII
|
|
|
|
PutString("VERSION \"\"\n\n\n");
|
|
PutString("NS_ :\n");
|
|
PutString(" NS_DESC_\n");
|
|
PutString(" CM_\n");
|
|
PutString(" BA_DEF_\n");
|
|
PutString(" BA_\n");
|
|
PutString(" VAL_\n");
|
|
PutString(" CAT_DEF_\n");
|
|
PutString(" CAT_\n");
|
|
PutString(" FILTER\n");
|
|
PutString(" BA_DEF_DEF_\n");
|
|
PutString(" EV_DATA_\n");
|
|
PutString(" ENVVAR_DATA_\n");
|
|
PutString(" SGTYPE_\n");
|
|
PutString(" SGTYPE_VAL_\n");
|
|
PutString(" BA_DEF_SGTYPE_\n");
|
|
PutString(" BA_SGTYPE_\n");
|
|
PutString(" SIG_TYPE_REF_\n");
|
|
PutString(" VAL_TABLE_\n");
|
|
PutString(" SIG_GROUP_\n");
|
|
PutString(" SIG_VALTYPE_\n");
|
|
PutString(" SIGTYPE_VALTYPE_\n");
|
|
PutString(" BO_TX_BU_\n");
|
|
PutString(" BA_DEF_REL_\n");
|
|
PutString(" BA_REL_\n");
|
|
PutString(" BA_DEF_DEF_REL_\n");
|
|
PutString(" BU_SG_REL_\n");
|
|
PutString(" BU_EV_REL_\n");
|
|
PutString(" BU_BO_REL_\n");
|
|
PutString(" SG_MUL_VAL_\n");
|
|
PutString("\n");
|
|
PutString("BS_:\n");
|
|
PutString("\nBU_:");
|
|
|
|
for (long ipN : gIpsSorted)
|
|
{
|
|
PutString(" Client_");
|
|
switch (NodeNameStyle) // Add the IP bytes depending on the style. Don't break anywhere.
|
|
{
|
|
case WholeIp:
|
|
PutString(gIpsSorted[ipN].Ip1);
|
|
PutString("_");
|
|
case ThreeLastBytes:
|
|
PutString(gIpsSorted[ipN].Ip2);
|
|
PutString("_");
|
|
case TwoLastBytes:
|
|
PutString(gIpsSorted[ipN].Ip3);
|
|
PutString("_");
|
|
case LastByte:
|
|
PutString(gIpsSorted[ipN].Ip4);
|
|
break;
|
|
default:
|
|
writeDbg(MbError, "The NodeNameStyle %d is unknown, please use a value of the enum!", NodeNameStyle);
|
|
runError(1001, 0);
|
|
return;
|
|
}
|
|
}
|
|
PutString("\n\n\n\n");
|
|
PutString("BA_DEF_ BU_ \"NodeLayerModules\" STRING ;\n");
|
|
PutString("BA_DEF_ \"DBName\" STRING ;\n");
|
|
PutString("BA_DEF_ \"BusType\" STRING ;\n");
|
|
PutString("BA_DEF_DEF_ \"NodeLayerModules\" \"Ethernet_IL.DLL\";\n");
|
|
PutString("BA_DEF_DEF_ \"DBName\" \"\";\n");
|
|
PutString("BA_DEF_DEF_ \"BusType\" \"Ethernet\";\n");
|
|
PutString("BA_ \"BusType\" \"Ethernet\";\n");
|
|
PutString("BA_ \"DBName\" \"Modbus\";\n");
|
|
|
|
f.Close();
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// The stuff below is not needed
|
|
/// <zzzModbus>
|
|
void OnModbusClientPanics(enum FatalErrors reason)
|
|
{
|
|
writeLineEx(0, 4, "<%NODE_NAME%> FATAL! %d", reason);
|
|
/* switch(reason)
|
|
{
|
|
case ParsingBuffer:
|
|
case ModbusPackageWasSplit:
|
|
case DeviceCodeUnknown:
|
|
case VendorIdUnknown:
|
|
case ConnectionError:
|
|
break;
|
|
}
|
|
*/
|
|
}
|
|
/// <zzzModbus>
|
|
void OnModbusWriteBitFailed(enum ModbusRequestError error, enum ModbusException ex, struct ModbusApHeader mbap){}
|
|
/// <zzzModbus>
|
|
void OnModbusWriteRegisterFailed(enum ModbusRequestError error, enum ModbusException ex, struct ModbusApHeader mbap){}
|
|
/// <zzzModbus>
|
|
void OnModbusWriteMasksFailed(enum ModbusRequestError error, enum ModbusException ex, struct ModbusApHeader mbap){}
|
|
/// <zzzModbus>
|
|
void OnModbusReadWriteRegistersFailed(enum ModbusRequestError error, enum ModbusException ex, struct ModbusApHeader mbap){}
|
|
/// <zzzModbus>
|
|
void OnModbusWriteBitsFailed(enum ModbusRequestError error, enum ModbusException ex, struct ModbusApHeader mbap){}
|
|
/// <zzzModbus>
|
|
void OnModbusWriteRegistersFailed(enum ModbusRequestError error, enum ModbusException ex, struct ModbusApHeader mbap){}
|
|
/// <zzzModbus>
|
|
void OnModbusWriteBitSuccess(struct ModbusResConfirmSingle mbc){}
|
|
/// <zzzModbus>
|
|
void OnModbusWriteRegisterSuccess(struct ModbusResConfirmSingle mbc){}
|
|
/// <zzzModbus>
|
|
void OnModbusWriteBitsSuccess(struct ModbusResConfirmMultiple mbc){}
|
|
/// <zzzModbus>
|
|
void OnModbusWriteRegistersSuccess(struct ModbusResConfirmMultiple mbc){}
|
|
/// <zzzModbus>
|
|
void OnModbusWriteMasksSuccess(struct ModbusResConfirmMasks mbc){} |