Originally reported by: Brian Thorne (Bitbucket: hardbyte, GitHub: hardbyte)

Similar to how the Bus is specialized for each inteface, the Message class can be as well.

Need to think about the prefered approach and at least document what that should be.

The old method was:

from can.interfaces import kvaser as interface
msg = interface.Message(...)

But for the Bus we are now using:

import can
bus = can.interface.Bus(...)

Alternatively, each interface could take generic Message objects and if necessary convert them - but I think there might be performance impacts for embedded devices with that option. Take a look at the kvaser interface which doesn't accept generic can.Message objects because it requires the flags attribute to be set.

Interested to hear thoughts...

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/33

Originally reported by: Nick Johnson (Bitbucket: nickjohnson, GitHub: nickjohnson)

It'd be really nice to be able to import the library and configure it in code, rather than it expecting configuration files; this isn't terribly useful behaviour for a library.

Further, the example here (https://bitbucket.org/hardbyte/python-can/src/4baa9ebb48c1fa6702613c617972ea46b5d4206f/examples/cyclic.py?at=default) no longer works; 'import can' throws "ImportError: CAN interface not found" on line 15.

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/13

Originally reported by: Travis Travelstead (Bitbucket: travis_travelstead, GitHub: Unknown)

Hello,

I am am very excited to use this library for communication on a CAN bus system I am developing. Right now the portion that is microcontroller based is working as expected but now I need to implement a GUI and data collection ideally using python and this library.

My issues is after installing the library, using "setup.py" as explained on the website, running the kernel "modprobe" command and creating a configuration file, I was unable to get "Bus()" object constructed. I keep getting an issue were it says there is not module called "interfaces" in "can".

I apologize is this is something simple that I am missing, but it would be helpful for myself and I guess others if there was a little bit more of a walkthrough on the initial setup.

I appreciate any time that is offered in helping me.

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/16

Originally reported by: Brian Thorne (Bitbucket: hardbyte, GitHub: hardbyte)

BCM Sockets

A type of managed can socket can be created on Linux to send and monitor cyclic messages. There isn't much kernel documentation of the bcm feature, although the header is be located at linux/can/bcm.h and the original documentation is found on brownhat

Putting this functionality into python-can would be ideal, especially in a backend independent way. For sending cyclic messages a function interface (as follows) might be enough, it could return a reference that can change the data, remove the cyclic transmission/subscription.

#!python

class CyclicSendTask:
    __init__(channel, message, period)
    stop()
    modify_data(updated_message)


def send_periodic(channel, message, period):
    return CyclicSendTask(channel, message, period)

The ability to create bcm sockets natively (on linux) is introduced in Python 3.4, ctypes can be used to bring the functionality back to Python 2.7. To keep a consistent API a user level implementation could be made for kvaser etc.

A C example using cyclic transmission and rx content filter subscription can be found here

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/9

Originally reported by: toonst (Bitbucket: toonst, GitHub: toonst)

Support for ISO TP is not yet built in SocketCAN by default, but there exists an implementation:
https://github.com/hartkopp/can-isotp

It would be great to be able to use this from python-can.

Since I really could use this functionality, I might take stab at implementing it. Could someone list the changes that are needed to make it work? I'm not familiar with the python-can code, so I don't know if this is feasible.

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/45

Originally reported by: Brian Thorne (Bitbucket: hardbyte, GitHub: hardbyte)

J1939 currently only works as an observer it doesn't ACK messages or send clear to sends.

A mechanism is required to register an address that should be owned by python-can so it deals with all long messages to or from that address.

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/10

Originally reported by: Michael Muldoon (Bitbucket: mbmuldoon07, GitHub: mbmuldoon07)

The can filters does not appear to work at least with socketcan_ctypes. I've tried anything I can think of when adding the can_filter to the bus but no matter what there appears to be no filtering.

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/25

Originally reported by: Brian Thorne (Bitbucket: hardbyte, GitHub: hardbyte)

The transmit threads don't prevent the Python interpreter from shutting down - which if they have out bound messages in their queue means messages won't get transmitted.

A simple but horrible solution is to wait or sleep after sending in a short program. A better solution would be great.

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/3

Originally reported by: nicktime (Bitbucket: nicktime, GitHub: nicktime)

https://python-can.readthedocs.org/en/latest/socketcan_ctypes.html#capturepacket
table is not represented right.

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/38

Originally reported by: Travis Travelstead (Bitbucket: travis_travelstead, GitHub: Unknown)

I am working on getting a python GUI to load during startup and python-can fails to load with this error.

raise ImportError("CAN interface not found")

After it fails and I am in userspace (as root) I run the same script and it runs without issue. My only guess is that it cannot load the required "can.config" file because it is not running as the root user yet.

Is is possible to fix this in the script or avoid the "can.config" file and just hardcode the interface information?

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/17

Originally reported by: Bruno Pennati (Bitbucket: radiocane, GitHub: radiocane)

Hi,
I cannot run examples/send_one.py (I've created .pth files in ~/.local/lib/python/ to make "import can" just work).
I've just forked and cloned the repo, without building it with python setup.py build, so maybe this is a non-issue.

#!bash
bruno@jeeg:~/src/python-can$ python examples/send_one.py 
Traceback (most recent call last):
  File "send_one.py", line 15, in <module>
    main()
  File "send_one.py", line 7, in main
    bus = can.interface.Bus()
TypeError: __new__() takes at least 3 arguments (2 given)

Similarly with python3

#!bash
bruno@jeeg:~/src/python-can$ python3 examples/send_one.py 
Traceback (most recent call last):
  File "send_one.py", line 15, in <module>
    main()
  File "send_one.py", line 7, in main
    bus = can.interface.Bus()
TypeError: __new__() missing 1 required positional argument: 'channel'

I've managed to manually create a bus with

#!bash
bruno@jeeg:~/src/python-can$ python3
Python 3.4.0 (default, Apr 11 2014, 13:05:11) 
[GCC 4.8.2] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import can
>>> bus = can.interface.Bus(channel='can0', bustype='socketcan')
>>>

Maybe this is similar to Issue #13

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/31

Originally reported by: Brian Thorne (Bitbucket: hardbyte, GitHub: hardbyte)

On it.

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/1

Originally reported by: Brian Thorne (Bitbucket: hardbyte, GitHub: hardbyte)

Add an additional argument (-i) to J1939_logger.py to specify the type of interface

Need to be able to specify the channel as can0 and interface as socketcan.

This functionality is implemented in the standard can_logger.py script so could basically copy the interface portions over.

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/46

Originally reported by: Axel C (Bitbucket: AxelC, GitHub: AxelC)

On windows for use of pcan interfece I have to edit

pycan.py line 7

FROM

from PCANBasic import *

TO

from can.interfaces.PCANBasic import *

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/20

Originally reported by: Nick Johnson (Bitbucket: nickjohnson, GitHub: nickjohnson)

Line 45 of socketcan_ctypes.py reads:

if timeout is None or len( select.select([self.socket], [], [], timeout=timeout)[0]) > 0:

Which causes the following exception:

TypeError: select() takes no keyword arguments

This can be fixed by removing 'timeout=' and passing the timeout as a positional argument.

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/12

Originally reported by: raashid ansari (Bitbucket: raashid_ansari, GitHub: Unknown)

Hi,

I am trying to send error frames on virtual can driver by setting "is_error_frame=True".

However, I am getting an error message that says, "Trying to send error frames - this won't work". Could you please help me in understanding this error? Does this mean that I won't be able to send error frames on a virtual bus as well as a real bus?

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/29

Originally reported by: Brian Thorne (Bitbucket: hardbyte, GitHub: hardbyte)

Since socketcan is linux only, the only backend that needs to be checked is the Kvaser interface.

Must work on Python 2, and would be ideal to work on Python 3 as well.

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/8

Originally reported by: Brian Thorne (Bitbucket: hardbyte, GitHub: hardbyte)

See https://gitorious.org/linux-can/can-utils

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/5

Originally reported by: Michal Gloc (Bitbucket: michalgloc, GitHub: Unknown)

Send_periodic fails. Interfaces seem to be missing CyclicSendTask.

Example:

task = can.send_periodic(channel='socketcan_ctypes', message=msg, period=0.1)

result:

task = can.send_periodic(channel=channel, message=msg, period=0.1)
File "/usr/local/lib/python2.7/dist-packages/python_can-1.4.1-py2.7.egg/can/broadcastmanager.py", line 75, in send_periodic
return can.interfaces.interface.CyclicSendTask(channel, message, period)
AttributeError: 'module' object has no attribute 'CyclicSendTask'

Same on python3 with socketcan_native.

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/44

Originally reported by: Florian Wilhelm (Bitbucket: florianwilhelm, GitHub: florianwilhelm)

Create a package and upload it to Pypi server - this would make the installation of this package much easier.

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/40

Originally reported by: Amr Bekhit (Bitbucket: amrbekhit, GitHub: amrbekhit)

Hello,

First off, thanks for a great library! I'm using Python 3.4 on an embedded ARM system running Kernel 3.15.1, and as recommended in the docs, the library is configured to use socketcan_native in the /etc/can.conf file. Unfortunately, none of the timeouts seem to be working. For example, if I create a bus object called "bus" and call bus.recv(1), the function just hangs indefinitely. Switching the library over to use socketcan_ctypes works OK. Any thoughts?

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/18

Originally reported by: Anonymous

I use this library python_can,In the preparation of the received message code, how to filter channel?I hope you get the help of friends!

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/49

Originally reported by: Daniele Paganelli (Bitbucket: mythsmith, GitHub: mythsmith)

Just try:

#!python

python2.7 -c "from can.interfaces.socketcan_native import *; print 1"

As module interface.py expects an ImportError to be raised, but no error is raised, the Bus initializator fails with:

WARNING:root:Kvaser canlib is unavailable.
WARNING:root:Function was not found in library
[... repeated many times...]
WARNING:root:Kvaser canlib is unavailable.
ERROR:can.socketcan.native:Note Python 3.3 or later is required to use native socketcan
Traceback (most recent call last):
  File "pycan.py", line 39, in <module>
    main()
  File "pycan.py", line 31, in main
    bus = can.interface.Bus(can_interface,bustype='socketcan_ctypes')
  File "/usr/local/lib/python2.7/dist-packages/can/interfaces/interface.py", line 50, in __new__
    cls = SocketscanCtypes_Bus
NameError: global name 'SocketscanCtypes_Bus' is not defined

For the moment I resolved by monkey-patching the interface.py module at import time:

#!python

from can.interfaces import socketcan_ctypes
from can.interfaces import interface
interface.SocketscanCtypes_Bus=socketcan_ctypes.SocketscanCtypes_Bus
from can.interfaces.interface import Bus

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/23

Originally reported by: Anonymous

I am trying to adapt virtual_can_demo.py to send messages to a real CAN device using the socketcan_ctypes interface and Python 2.7.

#!python

import can
can.rc['interface'] = 'socketcan_ctypes'
from can.interfaces.interface import Bus
can_interface = 'can0'

bus = Bus(can_interface)
msg = can.Message(arbitration_id=0x0cf02200, data=[1,2,3,4,5,6,7,8])
bus.send(msg)

bus.send(msg) raises the following error:

Traceback (most recent call last):
File "", line 1, in
File "can/interfaces/socketcan_ctypes.py", line 78, in send
sendPacket(self.socket, message)
NameError: global name 'message' is not defined

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/4

Originally reported by: Brian Thorne (Bitbucket: hardbyte, GitHub: hardbyte)

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/36

Originally reported by: SadE (Bitbucket: SadE, GitHub: SadE)

After successive connections, debugging a liitle test app , it seems the pcan dongle is not always released correctly.
My python app is closed , and when I'm trying to connect using PCAN Explorer I get this error :
Error in Connection Connection1: Hardware is already in use (Code 0400h)
Even by unplugging anf plugging it again, I get the same message.

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/48

Originally reported by: Brian Thorne (Bitbucket: hardbyte, GitHub: hardbyte)

As reported by @deva_deka

File "/usr/local/bin/can_logger.py", line 10, in <module>
    execfile(__file__)
  File "/home/.../python-can/bin/can_logger.py", line 71, in <module>
    bus = can.interface.Bus(results.channel, bustype=results.interface, can_filters=can_filters)
  File "/home/.../python-can/can/interfaces/interface.py", line 57, in __new__
    return cls(channel, **kwargs)
  File "/home/.../python-can/can/interfaces/kvaser/canlib.py", line 343, in __init__
    self._read_handle = canOpenChannel(channel, canOPEN_ACCEPT_VIRTUAL)
ctypes.ArgumentError: argument 1: <type 'exceptions.TypeError'>: wrong type

Can anyone with a kvaser help diagnose or confirm this?

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/47

Originally reported by: Brian Thorne (Bitbucket: hardbyte, GitHub: hardbyte)

Running the script:
$ j1939_logger.py -i socketcan_ctypes can0

On ubuntu with Python2 I cannot cleanly exit with Ctrl-C.

This doesn't happen on Python3.

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/7

Originally reported by: Brian Thorne (Bitbucket: hardbyte, GitHub: hardbyte)

I plan to set up some better automated testing using drone.io

https://drone.io/bitbucket.org/hardbyte/python-can

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/34

Originally reported by: Rajagopal sadhana babu (Bitbucket: sbrajagopal26, GitHub: sbrajagopal26)

I have created a config file as said but idle says no can module found. is it that saocket can only work with version 3.3. how to use the interface via ctypes?

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/21

Originally reported by: Olivier Bertrand (Bitbucket: lamoule74, GitHub: Unknown)

hello evb,
my question is simple:

I'm working on Linux for my development,
what is the difference between these 2 libraries ?

Sorry for my noobism :)
thanks in advance.
la moule.

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/41

Originally reported by: KotiReddy Marepally (Bitbucket: kmarepally, GitHub: Unknown)

Hello,

Is it possible to work with Vector CAN interfaces with same code base?
Could please help to enable Vector CAN interfaces(CanCase, VN1610)?

Regards,
Koti

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/22

Originally reported by: Olivier Bertrand (Bitbucket: lamoule74, GitHub: Unknown)

Hello,

I'm trying to use filters on my CAN network, simply by listening and receiving a frame...

It seems I don't understood how it works because I'm still receiving the frames with IDs not supposed to match with my filter...

I'm using the can_logger.py script for listening the network :
can_logger.py -i socketcan -c can0 --filter FFFFFFFF:1FFEFFFF

it is supposed to keep the frames equipped with this ID : 1FFEFFFF

see attached picture,

any Ideas ?
Thank you in advance...

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/37

Originally reported by: Bruno Pennati (Bitbucket: radiocane, GitHub: radiocane)

With the generic bustype='socketcan' the Bus.new() method tries to use socketcan_native when "import fcntl" does not raise an ImportError.
That is test is not good enough because it does not make sure that:

• we're running linux >= 2.6.25
• we're running python >= 3.3

If Linux is < 2.6.25 there is no SocketCAN, and if python < 3.3 socketcan_ctypes must be used.

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/32

Originally reported by: John Gehrig (Bitbucket: gehrigj, GitHub: Unknown)

Hello,

I just downloaded your library for a project, and it has been working wonderfully!

One minor issue I noticed, was that the timeout parameter for the recv() method of the socketcan_native interface is ignored. Am I using this correctly?

Here is the code which hangs (but shouldn't?)

#!python
import can
bus.recv(timeout=1)
bus = can.interface.Bus('can0', bustype='socketcan_native', can_filters=[])
bus.recv(timeout=1)

I made a quick hack to your source code on my system, as I needed this functionality for my application. But I am curious if this is an unimplemented feature, or if I am using the library incorrectly. If it is the prior, I have attached my quick and dirty fix for the feature.

I hope this is helpful, and thanks for the awesome library!

-John

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/28

Originally reported by: nick erb (Bitbucket: nerb, GitHub: nerb)

Neither python 2.7.5 nor python 3.3.3 will run the examples on Windows after a fresh install in a virtualenv.

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/11

Originally reported by: Sam Kreuze (Bitbucket: Kreuzade, GitHub: Kreuzade)

I've been trying for a while now to receive messages using this library with a PCAN device. I noticed today that the "recv" function does not use the "timeout" variable in the function in pcan.py. Is there a reason for this? or am I missing something?

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/42

Originally reported by: Brian Thorne (Bitbucket: hardbyte, GitHub: hardbyte)

There is some suspicious code in can/bus.py to do with locking around the bus. This is a holdover from problems I had with the kvaiser linux sdk not wanting multiple processes doing things on the bus at the same time.

A bit of an investigation is required to see how it effects socketcan, and ideally clean up that code.

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/2

Originally reported by: Travis Travelstead (Bitbucket: travis_travelstead, GitHub: Unknown)

I understand that with native support you are able to do kernel level ID filtering.

My question, is it possible to use userspace commands, like the ones used to setup the CAN socket. I see it is possible with the "candump" tool. This way with some userspace commands can supplement the missing feature.

example:
candump can0 -m 0x7FC -v 0x66 -t d

Below is the command I use to setup the CAN interface from my startup script and it would be great to do something similar to implement a lower level filter.
subprocess.call(['ip', 'link', 'set', 'can0', 'type', 'can', 'bitrate', '500000' , 'restart-ms' , '10000'])

I apologize because this crosses over into socketcan questions, but I think it would be a nice thing to add the work around to the documentation for kernel level message filtering.

Thanks for your time

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/19

Originally reported by: Steve Rice (Bitbucket: wulfman, GitHub: wulfman)

when i hit the clone button i get this
hg clone https://bitbucket.org/hardbyte/python-can
i have no idea what hg is supposed to do so i remove it and add git
git clone https://bitbucket.org/hardbyte/python-can
then i get a nice error
Cloning into 'python-can'...
fatal: https://bitbucket.org/hardbyte/python-can/info/refs not found: did you run git update-server-info on the server?
looking at the repo i do not see a python-can/info directory
am i going about this wrong ?
i have no issues using git on github

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/27

Originally reported by: nicktime (Bitbucket: nicktime, GitHub: nicktime)

Hi,

$ python3 -m examples.cyclic
Traceback (most recent call last):
  File "/usr/lib/python3.4/runpy.py", line 170, in _run_module_as_main
    "__main__", mod_spec)
  File "/usr/lib/python3.4/runpy.py", line 85, in _run_code
    exec(code, run_globals)
  File "/work/python-can/examples/cyclic.py", line 18, in <module>
    from can.interfaces.interface import Message, MultiRateCyclicSendTask
ImportError: cannot import name 'Message'
$ hg id
8f3908c6293c tip

PS I've setup vcan0.

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/39

Originally reported by: Jack Weinstein (Bitbucket: jacklev, GitHub: jacklev)

On 2.7 the PCAN interface doesn't release the net it creates. Should have a method in pcan.py that looks like this:

def shutdown(self):
    self.m_objPCANBasic.Uninitialize(self.m_PcanHandle)

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/26

Originally reported by: Kyle Altendorf (Bitbucket: altendky, GitHub: altendky)

Is it possible to configure a bus to add sent messages to the receive queue? I am writing an integrated script that both controls a device and logs all bus traffic. I would like the sent messages stored with accurate timestamps and logged as well. I am specifically working on Windows with PCANBasic but would be interested generally.

If not presently available, is anyone already familiar with whether or not the underlying libraries generally support this?

Thanks for your help.

Cheers,
-kyle

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/43

Originally reported by: LongQi Zhang (Bitbucket: zhanglongqi, GitHub: zhanglongqi)

The API is pretty straightforward.
But I still don't know how the listener works after reading the documents, could you create a example of how to use this class to create my own.

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/50

Originally reported by: Brian Thorne (Bitbucket: hardbyte, GitHub: hardbyte)

The overhead of filtering all traffic in python instead of in the kernel is massive.

This ticket is around adding first class support for socket can's ability to create filtered sockets.

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/6

Originally reported by: Colin Heinzmann (Bitbucket: DepthDeluxe, GitHub: DepthDeluxe)

I am trying to use the PCAN interface on Windows 7 with python-can and have followed the configuration instructions (i.e. https://bitbucket.org/hardbyte/python-can). When I try to "import can", I get the following error message even when I have explicitly stated to use the pcan interface in the configuration file.

WARNING:root:Kvaser canlib is unavailable.
WARNING:root:Function was not found in library
WARNING:root:Function was not found in library
WARNING:root:Function was not found in library
WARNING:root:Function was not found in library
WARNING:root:Function was not found in library
WARNING:root:Function was not found in library
WARNING:root:Function was not found in library
WARNING:root:Function was not found in library
WARNING:root:Function was not found in library
WARNING:root:Function was not found in library
WARNING:root:Function was not found in library
WARNING:root:Function was not found in library
WARNING:root:Function was not found in library
WARNING:root:Function was not found in library
WARNING:root:Function was not found in library
WARNING:root:Function was not found in library
WARNING:root:Function was not found in library
WARNING:root:Kvaser canlib is unavailable.
ERROR:can.serial:You won't be able to use the serial can backend without the serial module installed!

My can.ini/can.conf file contains:

[default]
interface = pcan
channel = 1

The Kvaser canlib missing error is also strange because while I was trying to fix the issue, I installed the Kvaser canlib SDK.

My Python version is 2.7.10 (32-bit) and I'm running Windows 7.

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/30

Originally reported by: Travis Travelstead (Bitbucket: travis_travelstead, GitHub: Unknown)

Hello,

I planned on testing this but since it might be a quick answer that others might be interested in as well I decided to ask.

I want to know if instead of installing using "setup.py" if I can just copy the source folder for "can" with my source to allow for simpler deployment which I do need to require the install to the device? Is there any dependancies that need to be installed/configured that the "setup.py" is required for.

Thanks

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/35

Originally reported by: raashid ansari (Bitbucket: raashid_ansari, GitHub: Unknown)

Apologies if this is the wrong portal for this issue. Although, I would like if someone can give me an idea.

I was wondering if python-can supports multiple can nodes on a virtual bus (vcan0).
I want to send multiple messages with different arbitration IDs simultaneously on vcan0. Just like it happens on a real network so that I can observe the bus arbitration to favor the ID that is lower in order.

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/24

Originally reported by: Mahaveer Hanuman Share (Bitbucket: sharemahaveer, GitHub: sharemahaveer)

Hi ,
I am new to this python programming.

Recently, I have started working with python programming to communicate with PCAN-usb(Channel1) interfaced with ECU.
I was able to Initialize PCAN-USB, write message but i am unable to receive the data from it.

but while using the PCAN view Explorer-5 I am able to write and read the data but not with python programming.

can you please help out to fix this issue.

Thankingyou

"""
added main by icarreno
"""
if name == 'main':

msg = TPCANMsg()
tmstamp = TPCANTimestamp()
data = 0x22,0xF1,0x50
msg._fields_ = [ ("ID",0x602),("MSGTYPE", PCAN_MESSAGE_STATUS  ),("LEN",    3),("DATA", data) ]

______________________________________________________________________________________________

----------------Initializ---------------------------

_______________________________________________________________________________________________

can = PCANBasic()
result = can.Initialize(PCAN_USBBUS1, PCAN_BAUD_500K)
if result == PCAN_ERROR_OK:
    print "Getstatus:-",can.GetStatus(PCAN_USBBUS1)
    print "hardwar:-", can.GetValue(PCAN_USBBUS1,PCAN_DEVICE_NUMBER)

______________________________________________________________________________________________

--------------Writing/Sending _data------------------

______________________________________________________________________________________________

    wrtstat= can.Write(PCAN_USBBUS1,msg)
    if (wrtstat == PCAN_ERROR_OK):
        print "Message was sent"
    else:
        print "Error Occured during writing"

__________________________________________________________________________________________________

-------------Reading----------------------------------

_________________________________________________________________________________________________

    can.Read(PCAN_USBBUS1)
    status = PCAN_ERROR_QRCVEMPTY     
    print "beforeloop:-",status        
    while((status & PCAN_ERROR_QRCVEMPTY) == PCAN_ERROR_QRCVEMPTY):
       status,msg,Time = can.Read(PCAN_USBBUS1)
       print status
       if (status == PCAN_ERROR_OK):
           print "Message sucessfully received "
       else:
           error = can.GetErrorText(PCAN_ERROR_QRCVEMPTY , 0)
       print "inside loop:-", status
       time.sleep(1)

__________________________________________________________________________________________________

else:
    print "Init error!"

print "End"
can.Uninitialize(PCAN_USBBUS1)

output:-
Getstatus:- 8
hardwar:- (0, 255)
Message was sent
beforeloop:- 32
32
inside loop:- 32
4
inside loop:- 4
End

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/14

Originally reported by: Jeff Jasper (Bitbucket: jajasp1, GitHub: Unknown)

I noticed I was losing J1939 messages and noticed that there are two threads that remove messages from the queue containing received CAN messages. The first thread is the one from which the bus is iterated over (the client code) and the second being the thread that is created during the instantiation of the Notifier assigned to j1939_notifier.

The messages removed when iterating over the bus are expected. However, the messages removed from the Notifier assigned to j1939_notifier do not get passed on to anything and are lost.

I'll preface the following with the fact that it's not entirely clear what j1939_notifier is for (it appears that it might be a mechanism to send J1939 messages and notify the sender of the response?). A possible client (one that is not interested in sending any messages) code workaround might be to create a istener in the client code and override the listener assigned to j1939_notifier (not sure if this is even possible yet). Doing so would mean all messages would have to be received through the listener and not by iterating over the Bus.

• Bitbucket: https://bitbucket.org/hardbyte/python-can/issue/15