return os.path.join(beremiz_dir, *args)

def SetupI18n():

# Get folder containing translation files

localedir = os.path.join(beremiz_dir, "locale")

# Define locale domain

loc.AddCatalog(domain)

global default_locale

default_locale = locale.getdefaultlocale()[1]

clock_gettime(CLOCK_MONOTONIC, &cur_time);

fprintf(stderr, "Modbus client thread (%%d) - new cycle (%%ld:%%ld)!\n", client_node_id, cur_time.tv_sec, cur_time.tv_nsec);

*/

int req;

for (req=0; req < NUMBER_OF_CLIENT_REQTS; req ++){

/* just do the requests belonging to the client */

fprintf(stderr, "Modbus client thread (%%d): RUNNING Modbus request %%d (periodic = %%d flag_exec_req = %%d)\n",

client_node_id, req, client_nodes[client_requests[req].client_node_id].periodic_act, client_requests[req].flag_exec_req );

*/

int res_tmp = __execute_mb_request(req);

client_requests[req].tn_error_code = 0; // assume success

client_requests[req].flag_mb_error_code = client_requests[req].mb_error_code;

client_requests[req].flag_tn_error_code = client_requests[req].tn_error_code;

* If the current cycle was activated by user request we reset the flag used to ask to run it

*/

if (0 != client_requests[req].flag_exec_req) {

client_requests[req].flag_exec_started = 0;

}

//fprintf(stderr, "Modbus plugin: RUNNING<---> of Modbus request %%d (periodic = %%d flag_exec_req = %%d)\n",

// req, client_nodes[client_requests[req].client_node_id].periodic_act, client_requests[req].flag_exec_req );

}

* running (i.e. before or after __init_() ets called)!

*

* The following functions are never called from other C code. They are

* implements the web server extension for configuring Modbus parameters.

*/

* directly access the server_node_t and client_node_t structures,

* however this would create a tight coupling between these two

* disjoint pieces of code.

int __modbus_get_ClientNode_parity (int nodeid) {return client_nodes[nodeid].node_address.addr.rtu.parity; }

int __modbus_get_ClientNode_stop_bits (int nodeid) {return client_nodes[nodeid].node_address.addr.rtu.stop_bits;}

u64 __modbus_get_ClientNode_comm_period(int nodeid) {return client_nodes[nodeid].comm_period; }

const char * __modbus_get_ClientNode_addr_type (int nodeid) {return addr_type_str[client_nodes[nodeid].node_address.naf];}

const char * __modbus_get_ServerNode_config_name(int nodeid) {return server_nodes[nodeid].config_name; }

void __modbus_set_ClientNode_parity (int nodeid, int value) {client_nodes[nodeid].node_address.addr.rtu.parity = value;}

void __modbus_set_ClientNode_stop_bits (int nodeid, int value) {client_nodes[nodeid].node_address.addr.rtu.stop_bits = value;}

void __modbus_set_ClientNode_comm_period(int nodeid, u64 value) {client_nodes[nodeid].comm_period = value;}

void __modbus_set_ServerNode_host (int nodeid, const char * value) {if (strcmp(value,"#ANY#")==0) value = "";

node_addr_t node_address;

int mb_nd; // modbus library node used for this client

int init_state; // store how far along the client's initialization has progressed

int prev_error; // error code of the last printed error message (0 when no error)

pthread_t thread_id; // thread handling all communication for this client node

pthread_t timer_thread_id; // thread handling periodical timer for this client node

params: child - the correspondent subplugin in Beremiz

"""

node_init_template = '''/*node %(locnodestr)s*/

location = ".".join(map(str, child.GetCurrentLocation()))

node_dict = {"locnodestr": location,

"config_name": config_name,

"baud": baud,

"parity": modbus_serial_parity_dict[parity],

"stopbits": stopbits,

return node_init_template % node_dict

params: child - the correspondent subplugin in Beremiz

"""

node_init_template = '''/*node %(locnodestr)s*/

location = ".".join(map(str, child.GetCurrentLocation()))

node_dict = {"locnodestr": location,

"config_name": config_name,

"host": host,

"port": port,

return node_init_template % node_dict

</xsd:restriction>

</xsd:simpleType>

</xsd:attribute>

</xsd:complexType>

</xsd:element>

</xsd:schema>

"""

# corresponds to aprox 25 days.

CTNChildrenTypes = [("ModbusRequest", _RequestPlug, "Request")]

# TODO: Replace with CTNType !!!

</xsd:restriction>

</xsd:simpleType>

</xsd:attribute>

</xsd:complexType>

</xsd:element>

</xsd:schema>

"""

# corresponds to aprox 25 days.

CTNChildrenTypes = [("ModbusRequest", _RequestPlug, "Request")]

# TODO: Replace with CTNType !!!

# annotate.Integer, ...)

("host" , _("Remote IP Address") , ctypes.c_char_p, MB_StrippedString),

("port" , _("Remote Port Number") , ctypes.c_char_p, MB_StrippedString),

]

RTUclient_parameters = [

("baud" , _("Baud Rate") , ctypes.c_int, MB_Baud ),

("parity" , _("Parity") , ctypes.c_int, MB_Parity ),

("stop_bits" , _("Stop Bits") , ctypes.c_int, MB_StopBits ),

]

TCPserver_parameters = [

<xsd:element name="Linux">

<xsd:complexType>

%(toolchain_gcc)s

</xsd:complexType>

\ No newline at end of file

extension = ".so"

def getBuilderCFLAGS(self):

def getBuilderLDFLAGS(self):

return toolchain_gcc.getBuilderLDFLAGS(self) + ["-shared", "-lrt"]

#include <pthread.h>

#include <locale.h>

#include <semaphore.h>

static unsigned long __debug_tick;

pthread_exit(0);

}

#define maxval(a,b) ((a>b)?a:b)

int startPLC(int argc,char **argv)

{

PLC_shutdown = 0;

pthread_mutex_lock(&debug_wait_mutex);

pthread_mutex_lock(&python_wait_mutex);

/* Signal to wakeup PLC thread when period changes */

signal(SIGUSR1, PLCThreadSignalHandler);

period_ns = common_ticktime__;

clock_gettime(CLOCK_MONOTONIC, &next_abs_time);

}else{

}

return 0;

}

{

unsigned long thread_id = 0;

BOOL tmp;

debug_sem = CreateSemaphore(

NULL, // default security attributes

int unblock_RT_to_nRT_signal(void* handle);

void nRT_reschedule(void);

#endif

default:

break;

}

}

/* Reset buffer cursor */