Fixed iso15765-2 transmit / receive.

-Fixed iso15765_receive_message(), was useless before.
-Fixed cm_iso157652_tx_message_object data not being able to assign a tuple
or list
-Fixed cm_iso157652_*x_message_object flags variable truncating to first
byte.
-Added iso15765-2 example.

Signed-off-by: David Rebbe <drebbe@intrepidcs.com>

Author: drebbe-intrepid

examples/iso15765_example.py

@@ -0,0 +1,131 @@
+import ics
+
+enable_print_message = False
+enable_use_server = True
+
+# Helper Functions ##########################################################
+def dev_name(device):
+    if int("AA0000", 36) < device.SerialNumber < int("ZZZZZZ", 36):
+        return device.Name + " " + ics.base36enc(device.SerialNumber)
+    else:
+        return device.Name + " " + str(device.SerialNumber)
+
+def print_message(msg):
+    if not enable_print_message:
+        if isinstance(msg, ics.SpyMessage):
+            print('\tArbID: {}\tData: {}'.format(hex(msg.ArbIDOrHeader), [hex(x) for x in msg.Data]))
+        return
+    print('\t' + str(type(msg)))
+    for attribute in dir(msg):
+        if attribute.startswith("_"):
+            continue
+        length = len(attribute)
+        if attribute == 'data':
+            print("\t\t{}:{}{}".format(attribute, " "*(30-length), msg.data[:msg.num_bytes]))
+        else:
+            value = getattr(msg, attribute)
+            try:
+                value = hex(value)
+            except:
+                pass
+            print("\t\t{}:{}{}".format(attribute, " "*(30-length), value))
+    print()
+
+def open_device(index=0):
+    device = None
+    if enable_use_server:
+        # ics.open_device() won't open a device if we have handles open already
+        # so we need to find them and specify which ones to connect to.
+        devices = ics.find_devices()
+        print("Opening Device {} (Open Client handles: {})...".format(dev_name(devices[index]), devices[index].NumberOfClients))
+        ics.open_device(devices[index])
+        device = devices[index]
+    else:
+        print("Opening Device...")
+        device = ics.open_device()
+    print("Opened Device %s." % dev_name(device))
+    return device
+
+# Iso15765 Fuctions #########################################################
+def transmit_iso15765_msg(device, netid=ics.NETID_HSCAN, is_canfd=False):
+    number_of_bytes = 64
+    msg = ics.CmISO157652TxMessage()
+    msg.id = 0x7E0
+    msg.vs_netid = netid
+    msg.num_bytes = number_of_bytes
+    msg.padding = 0xAA
+    # Flow Control
+    msg.fc_id = 0x7E8
+    msg.fc_id_mask = 0xFFF
+    msg.flowControlExtendedAddress = 0xFE
+    msg.fs_timeout = 0x10 # ms
+    msg.fs_wait = 0x3000 # ms
+    msg.blockSize = 0
+    msg.stMin = 0
+    # CmISO157652TxMessage.flags bitfield union isn't implemented as of 2.12, we need to do it manually.
+    msg.flags = 0
+    # paddingEnable
+    msg.flags |= (1 << 6)
+    # CANFD: Enable + BRS
+    if is_canfd:
+        msg.flags |= (1 << 7) | (1 << 8)
+    # tx_dl
+    msg.flags |= (8 << 24)
+    # Data
+    msg.data = [x for x in range(number_of_bytes)]
+    
+    # Transmit the message
+    print("Transmitting iso15765 message on {}...".format(dev_name(device)))
+    ics.iso15765_transmit_message(device, netid, msg, 3000)
+    # Wait for the messages to be transmitted, this can be calculated a lot better but works here.
+    time.sleep((((number_of_bytes/8)*msg.fs_timeout)/1000.0)+0.5)
+    #print_message(msg)
+    print("Transmitted iso15765 message on {}.".format(dev_name(device)))
+
+def setup_rx_iso15765_msg(device, netid=ics.NETID_HSCAN, is_canfd=False):
+    msg = ics.CmISO157652RxMessage()
+
+    msg.id = 0x7E0
+    msg.vs_netid = netid
+    msg.padding = 0xAA
+    msg.id_mask = 0xFFF
+    msg.fc_id = 0x7E8
+    msg.blockSize = 100
+    msg.stMin = 10
+    msg.cf_timeout = 1000
+    # CmISO157652RxMessage.flags bitfield union isn't implemented as of 2.12, we need to do it manually.
+    msg.flags = 0
+    # paddingEnable
+    msg.flags |= (1 << 6)
+    # CANFD: Enable + BRS
+    if is_canfd:
+        msg.flags |= (1 << 7) | (1 << 8)
+
+    print_message(msg)
+    print("Setting up iso15765 message on {}...".format(dev_name(device)))
+    ics.iso15765_receive_message(device, netid, msg)
+    print("Setup iso15765 message on {}.".format(dev_name(device)))
+    
+
+def get_iso15765_msgs(device):
+    msgs, error_count = ics.get_messages(device)
+    print("Received {} messages with {} errors.".format(len(msgs), error_count))
+    for i, m in enumerate(msgs):
+        print('Message #{}\t'.format(i+1), end='')
+        print_message(m)
+    
+if __name__ == "__main__":
+    import time
+    netid = ics.NETID_HSCAN
+    
+    tx_device = open_device(0)
+    rx_device = open_device(1)
+    
+    ics.iso15765_enable_networks(tx_device, netid)
+    ics.iso15765_enable_networks(rx_device, netid)
+    setup_rx_iso15765_msg(rx_device)
+    transmit_iso15765_msg(tx_device)
+    get_iso15765_msgs(rx_device)
+    
+    ics.iso15765_disable_networks(tx_device)
+    ics.iso15765_disable_networks(rx_device)

include/methods.h

@@ -1007,13 +1007,15 @@ PyObject* meth_enable_network_com(PyObject* self, PyObject* args);
 
 // (void* hObject, unsigned int iIndex, const stCM_ISO157652_RxMessage * pRxMessage)
 #define _DOC_ISO15765_RECEIVE_MESSAGE \
-    MODULE_NAME".iso15765_receive_message(device, iIndex)\n" \
+    MODULE_NAME".iso15765_receive_message(device, netid, rx_msg)\n" \
     "\n" \
-    "Receives an ISO15765 Message.\n" \
+    "Setup rx ISO15765 Message.\n" \
     "\n" \
     "Args:\n" \
     "\tdevice (:class:`"MODULE_NAME"."NEO_DEVICE_OBJECT_NAME"`): :class:`"MODULE_NAME"."NEO_DEVICE_OBJECT_NAME"`\n\n" \
     "\n" \
+    "\tprx_msg (:class:`"MODULE_NAME"."CM_ISO157652_RX_MESSAGE_OBJECT_NAME"`): :class:`"MODULE_NAME"."CM_ISO157652_RX_MESSAGE_OBJECT_NAME"`\n\n" \
+    "\n" \
     "Raises:\n" \
     "\t:class:`"MODULE_NAME".RuntimeError`\n" \
     "\n" \

include/object_cm_iso157652_rx_message.h

@@ -48,7 +48,7 @@ static PyMemberDef cm_iso157652_rx_message_object_members[] = {
     { "stMin", T_UBYTE, offsetof(cm_iso157652_rx_message_object, s.stMin), 0, "Minimum seperation time (between consecutive frames) to report in flow control response"},
     { "cf_timeout", T_USHORT, offsetof(cm_iso157652_rx_message_object, s.cf_timeout), 0, "max timeout (ms) for waiting on consecutive frame.  Set this to N_CR_MAX's value in J2534"},
     // TODO: Support bit fields here
-    { "flags", T_UBYTE, offsetof(cm_iso157652_rx_message_object, s.flags), 0, ""},
+    { "flags", T_UINT, offsetof(cm_iso157652_rx_message_object, s.flags), 0, ""},
     { "reserved", T_OBJECT_EX, offsetof(cm_iso157652_rx_message_object, s.reserved), 0, ""},
     { NULL, 0, 0, 0, 0 },
 };

include/object_cm_iso157652_tx_message.h

@@ -52,7 +52,7 @@ static PyMemberDef cm_iso157652_tx_message_object_members[] = {
     { "data", T_OBJECT_EX, offsetof(cm_iso157652_tx_message_object, s.data), 0, "The data"},
     { "num_bytes", T_UINT, offsetof(cm_iso157652_tx_message_object, s.num_bytes), 0, "Number of data bytes"},
     // TODO: Support bit fields here
-    { "flags", T_UBYTE, offsetof(cm_iso157652_tx_message_object, s.flags), 0, ""},
+    { "flags", T_UINT, offsetof(cm_iso157652_tx_message_object, s.flags), 0, ""},
     { NULL, 0, 0, 0, 0 },
 };
 
@@ -97,7 +97,7 @@ static int cm_iso157652_tx_message_object_setattr(PyObject *o, PyObject *name, P
     cm_iso157652_tx_message_object* obj = (cm_iso157652_tx_message_object*)o;
     if (PyUnicode_CompareWithASCIIString(name, "data") == 0) {
         // Make sure we are a tuple and len() == 8
-        if (!PyTuple_Check(value) || !PyList_Check(value)) {
+        if (!PyTuple_Check(value) && !PyList_Check(value)) {
             PyErr_Format(PyExc_AttributeError,
                 "'%.50s' object attribute '%.400s' needs to be a tuple or list",
                 MODULE_NAME "." CM_ISO157652_TX_MESSAGE_OBJECT_NAME, name);

src/methods.cpp

@@ -3673,37 +3673,45 @@ PyObject* obj = NULL;
 PyObject* meth_iso15765_receive_message(PyObject* self, PyObject* args)
 {
     PyObject* obj = NULL;
+    PyObject* obj_rx_msg = NULL;
     unsigned int iIndex = 0;
-    PyObject* obj_rx_msg = PyObject_CallObject((PyObject*)&cm_iso157652_rx_message_object_type, NULL);
-    if (!PyArg_ParseTuple(args, arg_parse("Oi:", __FUNCTION__), &obj, &iIndex)) {
+    //PyObject* obj_rx_msg = PyObject_CallObject((PyObject*)&cm_iso157652_rx_message_object_type, NULL);
+    if (!PyArg_ParseTuple(args, arg_parse("OiO:", __FUNCTION__), &obj, &iIndex, &obj_rx_msg)) {
         return NULL;
     }
     if (!PyNeoDevice_CheckExact(obj)) {
         return set_ics_exception(exception_runtime_error(), "Argument must be of type " MODULE_NAME "." NEO_DEVICE_OBJECT_NAME);
     }
-    if (!PyCmISO157652TxMessage_Check(obj_rx_msg)) {
+    if (!PyCmISO157652RxMessage_Check(obj_rx_msg)) {
         return set_ics_exception(exception_runtime_error(), "Argument must be of type " MODULE_NAME "." CM_ISO157652_RX_MESSAGE_OBJECT_NAME);
     }
+    Py_XINCREF(obj_rx_msg);
     cm_iso157652_rx_message_object *temp = (cm_iso157652_rx_message_object*)obj_rx_msg;
     ICS_HANDLE handle = PyNeoDevice_GetHandle(obj);
     try
     {
         ice::Library* lib = dll_get_library();
         if (!lib) {
             char buffer[512];
+            Py_DECREF(obj_rx_msg);
             return set_ics_exception(exception_runtime_error(), dll_get_error(buffer));
         }
+        //stCM_ISO157652_RxMessage rx_msg_temp = {0};
+        //memcpy(&rx_msg_temp, &(temp->s), sizeof(temp->s));
         ice::Function<int __stdcall (ICS_HANDLE, unsigned int, stCM_ISO157652_RxMessage*)> icsneoISO15765_ReceiveMessage(lib, "icsneoISO15765_ReceiveMessage");
         Py_BEGIN_ALLOW_THREADS
         if (!icsneoISO15765_ReceiveMessage(handle, iIndex, &temp->s)) {
             Py_BLOCK_THREADS
+            Py_DECREF(obj_rx_msg);
             return set_ics_exception(exception_runtime_error(), "icsneoISO15765_ReceiveMessage() Failed");
         }
         Py_END_ALLOW_THREADS
-        return obj_rx_msg;
+        Py_DECREF(obj_rx_msg);
+        Py_RETURN_NONE;
     }
     catch (ice::Exception& ex)
     {
+        Py_DECREF(obj_rx_msg);
         return set_ics_exception(exception_runtime_error(), (char*)ex.what());
     }
     return set_ics_exception(exception_runtime_error(), "This is a bug!");