python-can-j1939 0.1.0__py3-none-any.whl

python_can_j1939-0.1.0.dist-info/METADATA

@@ -0,0 +1,325 @@
+Metadata-Version: 2.4
+Name: python-can-j1939
+Version: 0.1.0
+Summary: SAE J1939 stack implementation (fork of can-j1939 by Juergen Heilgemeir)
+Author: Raul Sainz-Maza, Drew Rife, Grant Allan, Koltan Hauersperger, Mahesh Sharma, Todd Snider, Victor Klueber
+Maintainer: Raul Sainz-Maza
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/RaulSMS/python-can-j1939
+Project-URL: Bug Tracker, https://github.com/RaulSMS/python-can-j1939/issues
+Project-URL: Documentation, https://python-can-j1939.readthedocs.io/en/latest/
+Keywords: CAN,SAE,J1939,J1939-FD,J1939-22
+Classifier: Development Status :: 4 - Beta
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: python-can>=4.2.0
+Provides-Extra: test
+Requires-Dist: pytest>=6.2.5; extra == "test"
+Dynamic: license-file
+
+# SAE J1939 for Python
+
+[![Latest Version on PyPi](https://img.shields.io/pypi/v/python-can-j1939)](https://pypi.org/project/python-can-j1939/)
+[![Documentation build Status](https://readthedocs.org/projects/python-can-j1939/badge/?version=latest)](https://python-can-j1939.readthedocs.io/en/latest/)
+
+An implementation of the CAN SAE J1939 standard for Python. This is the
+first J1939-22 (J1939-FD) implementation!
+
+If you experience a problem or think the stack would not behave
+properly, do not hesitate to open a ticket or write an email.
+Pull Requests (PR) are of course even more welcome!
+
+The project uses the
+[python-can](https://python-can.readthedocs.org/en/stable/) package to
+support multiple hardware drivers. At the time of writing the supported
+interfaces are
+
+- CAN over Serial
+- CAN over Serial / SLCAN
+- CANalyst-II
+- IXXAT Virtual CAN Interface
+- Kvasers CANLIB
+- NEOVI Interface
+- NI-CAN
+- PCAN Basic API
+- Socketcan
+- SYSTEC interface
+- USB2CAN Interface
+- Vector
+- Virtual
+- isCAN
+
+## Overview
+
+An SAE J1939 CAN Network consists of multiple Electronic Control Units
+(ECUs). Each ECU can have one or more Controller Applications (CAs).
+Each CA has its own (unique) Address on the bus. This address is either
+acquired within the address claiming procedure or set to a fixed value.
+In the latter case, the CA has to announce its address to the bus to
+check whether it is free.
+
+The CAN messages in a SAE J1939 network are called Protocol Data Units
+(PDUs). This definition is not completely correct, but close enough to
+think of PDUs as the CAN messages.
+
+## Features
+
+- one ElectronicControlUnit (ECU) can hold multiple
+    ControllerApplications (CA)
+- ECU (CA) Naming according SAE J1939/81
+- full featured address claiming procedure according SAE J1939/81
+- full support of transport protocol (up to 1785 bytes) according SAE
+    J1939/21 for sending and receiving
+  - Connection Mode Data Transfers (CMDT)
+  - Broadcast Announce Message (BAM)
+- support of Multi-PG according SAE J1939/22
+  - currently FEFF (Flexible Data Rate Extended Frame Format)
+        supported only
+- full support of fd-transport protocol according SAE J1939/22
+    (J1939-FD) for sending and receiving
+  - RTS/CTS (Destination Specific) Transfer with up to 8 concurrent
+        sessions and up to 16777215 bytes of data per session
+  - Broadcast Announce Message (BAM) with up to 4 concurrent
+        sessions and up to 15300 bytes of data per session
+- Requests (global and specific)
+- correct timeout and deadline handling
+- (under construction) almost complete testcoverage
+- diagnostic messages (see
+    <https://github.com/RaulSMS/python-can-j1939/tree/master/examples/diagnostic_message.py>)
+  - support of DM1 Tool and ECU functionaliy (all four SAE J1939-73
+        SPN conversion methods: 1, 2, 3, 4)
+  - support of DM11 Tool functionaliy
+  - support of DM22 Tool functionaliy
+
+## Installation
+
+Requires **Python 3.10 or later** and python-can_ >= 4.2.0.
+
+Install python-can-j1939 with pip:
+
+    pip install python-can-j1939
+
+or do the trick with:
+
+    git clone https://github.com/RaulSMS/python-can-j1939.git
+    cd python-can-j1939
+    pip install .
+
+## Upgrade
+
+Upgrade an already installed python-can-j1939 package:
+
+    pip install --upgrade python-can-j1939
+
+## Quick start
+
+To simply receive all passing (public) messages on the bus you can
+subscribe to the ECU object.
+
+``` python
+import logging
+import time
+import can
+import j1939
+
+logging.getLogger('j1939').setLevel(logging.DEBUG)
+logging.getLogger('can').setLevel(logging.DEBUG)
+
+def on_message(priority, pgn, sa, timestamp, data):
+    """Receive incoming messages from the bus
+
+    :param int priority:
+        Priority of the message
+    :param int pgn:
+        Parameter Group Number of the message
+    :param int sa:
+        Source Address of the message
+    :param int timestamp:
+        Timestamp of the message
+    :param bytearray data:
+        Data of the PDU
+    """
+    print("PGN {} length {}".format(pgn, len(data)))
+
+def main():
+    print("Initializing")
+
+    # create the ElectronicControlUnit (one ECU can hold multiple ControllerApplications)
+    ecu = j1939.ElectronicControlUnit()
+
+    # Connect to the CAN bus
+    # Arguments are passed to python-can's can.interface.Bus() constructor
+    # (see https://python-can.readthedocs.io/en/stable/bus.html).
+    # ecu.connect(bustype='socketcan', channel='can0')
+    # ecu.connect(bustype='kvaser', channel=0, bitrate=250000)
+    ecu.connect(bustype='pcan', channel='PCAN_USBBUS1', bitrate=250000)
+    # ecu.connect(bustype='ixxat', channel=0, bitrate=250000)
+    # ecu.connect(bustype='vector', app_name='CANalyzer', channel=0, bitrate=250000)
+    # ecu.connect(bustype='nican', channel='CAN0', bitrate=250000)
+
+    # subscribe to all (global) messages on the bus
+    ecu.subscribe(on_message)
+
+    time.sleep(120)
+
+    print("Deinitializing")
+    ecu.disconnect()
+
+if __name__ == '__main__':
+    main()
+```
+
+A more sophisticated example in which the CA class was overloaded to
+include its own functionality:
+
+``` python
+import logging
+import time
+import can
+import j1939
+
+logging.getLogger('j1939').setLevel(logging.DEBUG)
+logging.getLogger('can').setLevel(logging.DEBUG)
+
+# compose the name descriptor for the new ca
+name = j1939.Name(
+    arbitrary_address_capable=0,
+    industry_group=j1939.Name.IndustryGroup.Industrial,
+    vehicle_system_instance=1,
+    vehicle_system=1,
+    function=1,
+    function_instance=1,
+    ecu_instance=1,
+    manufacturer_code=666,
+    identity_number=1234567
+    )
+
+# create the ControllerApplications
+ca = j1939.ControllerApplication(name, 128)
+
+
+def ca_receive(priority, pgn, source, timestamp, data):
+    """Feed incoming message to this CA.
+    (OVERLOADED function)
+    :param int priority:
+        Priority of the message
+    :param int pgn:
+        Parameter Group Number of the message
+    :param intsa:
+        Source Address of the message
+    :param int timestamp:
+        Timestamp of the message
+    :param bytearray data:
+        Data of the PDU
+    """
+    print("PGN {} length {}".format(pgn, len(data)))
+
+def ca_timer_callback1(cookie):
+    """Callback for sending messages
+
+    This callback is registered at the ECU timer event mechanism to be
+    executed every 500ms.
+
+    :param cookie:
+        A cookie registered at 'add_timer'. May be None.
+    """
+    # wait until we have our device_address
+    if ca.state != j1939.ControllerApplication.State.NORMAL:
+        # returning true keeps the timer event active
+        return True
+
+    # create data with 8 bytes
+    data = [j1939.ControllerApplication.FieldValue.NOT_AVAILABLE_8] * 8
+
+    # sending normal broadcast message
+    ca.send_pgn(0, 0xFD, 0xED, 6, data)
+
+    # sending normal peer-to-peer message, destintion address is 0x04
+    ca.send_pgn(0, 0xE0, 0x04, 6, data)
+
+    # returning true keeps the timer event active
+    return True
+
+
+def ca_timer_callback2(cookie):
+    """Callback for sending messages
+
+    This callback is registered at the ECU timer event mechanism to be
+    executed every 500ms.
+
+    :param cookie:
+        A cookie registered at 'add_timer'. May be None.
+    """
+    # wait until we have our device_address
+    if ca.state != j1939.ControllerApplication.State.NORMAL:
+        # returning true keeps the timer event active
+        return True
+
+    # create data with 100 bytes
+    data = [j1939.ControllerApplication.FieldValue.NOT_AVAILABLE_8] * 100
+
+    # sending multipacket message with TP-BAM
+    ca.send_pgn(0, 0xFE, 0xF6, 6, data)
+
+    # sending multipacket message with TP-CMDT, destination address is 0x05
+    ca.send_pgn(0, 0xD0, 0x05, 6, data)
+
+    # returning true keeps the timer event active
+    return True
+
+def main():
+    print("Initializing")
+
+    # create the ElectronicControlUnit (one ECU can hold multiple ControllerApplications)
+    ecu = j1939.ElectronicControlUnit()
+
+    # Connect to the CAN bus
+    # Arguments are passed to python-can's can.interface.Bus() constructor
+    # (see https://python-can.readthedocs.io/en/stable/bus.html).
+    # ecu.connect(bustype='socketcan', channel='can0')
+    # ecu.connect(bustype='kvaser', channel=0, bitrate=250000)
+    ecu.connect(bustype='pcan', channel='PCAN_USBBUS1', bitrate=250000)
+    # ecu.connect(bustype='ixxat', channel=0, bitrate=250000)
+    # ecu.connect(bustype='vector', app_name='CANalyzer', channel=0, bitrate=250000)
+    # ecu.connect(bustype='nican', channel='CAN0', bitrate=250000)
+    # ecu.connect('testchannel_1', bustype='virtual')
+
+    # add CA to the ECU
+    ecu.add_ca(controller_application=ca)
+    ca.subscribe(ca_receive)
+    # callback every 0.5s
+    ca.add_timer(0.500, ca_timer_callback1)
+    # callback every 5s
+    ca.add_timer(5, ca_timer_callback2)
+    # by starting the CA it starts the address claiming procedure on the bus
+    ca.start()
+
+    time.sleep(120)
+
+    print("Deinitializing")
+    ca.stop()
+    ecu.disconnect()
+
+if __name__ == '__main__':
+    main()
+```
+
+## Credits
+
+This package is a fork of
+[can-j1939](https://github.com/juergenH87/python-can-j1939) by Juergen
+Heilgemeir, who greatly extended the original work and added J1939-22
+(J1939-FD) support.
+
+The original implementation was taken from
+<https://github.com/benkfra/j1939> by Frank Benkert.
+
+Thanks to all contributors for their great work!

python_can_j1939-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+j1939/Dm14Query.py,sha256=1SUGtwd23w56V0ZOxQs7KCHhff7GdMxGbPwEdc8PhcM,12226
+j1939/Dm14Server.py,sha256=ftOtW1J6ix5cIbrtUZZcAwtkvb7Trk5jeEPQBDXvyI4,13838
+j1939/__init__.py,sha256=Jr9uygL7C57iAgD0HHtHBn4onzAyEEJkpiQ2g6f8fv4,405
+j1939/controller_application.py,sha256=wkDDZXqB5H6Z8ZWu-LqJhWzfCW4kX6mUBwobFeabBuI,16310
+j1939/diagnostic_messages.py,sha256=HjzZ-dT_qMW7sLqYQXutDKBnHrPY_u2XP7J-sqmM9yo,15179
+j1939/electronic_control_unit.py,sha256=0sYfpbf1GCwHl0U4ehw_evIE5qRL5rYxXV7yzJdG4G8,19649
+j1939/error_info.py,sha256=oMT8QJUsPnXym3elmyHl4Hxt9ObXw1pxMTqBK1uVlGM,4154
+j1939/j1939_21.py,sha256=Nt7yjdXuwtLxBD_KjJFLzB3yA6hCJLzZdomOQckqUHM,28526
+j1939/j1939_22.py,sha256=yFiWa5dgfpLRd3-WD6p9VAVys-9392zsBmrLxIq6ApQ,44083
+j1939/memory_access.py,sha256=2pHyjJsGXCUirKamPmItnhpYhrOnbUgmWdPV9tXxXyI,15304
+j1939/message_id.py,sha256=AGU-sg74lqmqxlZFNNHjOYyz_jtASDY5kT76yb82GGU,1839
+j1939/name.py,sha256=x-Tr6I2MUTChEf3C9BCQQe9qnvMzm5pseqRlnUr_OVI,10322
+j1939/parameter_group_number.py,sha256=Q1U-GZuckYhQiIxAOjP1LGYDzQMla0nb232FQS5E9Jw,5323
+j1939/version.py,sha256=Pru0BlFBASFCFo7McHdohtKkUtgMPDwbGfyUZlE2_Vw,21
+python_can_j1939-0.1.0.dist-info/licenses/LICENSE,sha256=A5rtfN-Go8YRj8h812jydwJEPT6NIC1rLVQtHfVyOTs,1130
+python_can_j1939-0.1.0.dist-info/METADATA,sha256=ccoR5VMWJjP3wlGCdgSZeugLPi1RaZpV8bWNMdaxWdQ,10455
+python_can_j1939-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+python_can_j1939-0.1.0.dist-info/top_level.txt,sha256=DuSapIvGxz2GN_YXQAigYWEn-nqGoxEfJL12LrvTsrA,6
+python_can_j1939-0.1.0.dist-info/RECORD,,

python_can_j1939-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

python_can_j1939-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2018 Frank Benkert (opensource@frank-benkert.de)
+Copyright (c) 2021 juergenH87
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

python_can_j1939-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+j1939