can

README

can

can provides an interface to a CAN bus to read and write frames. The library is based on the SocketCAN network stack on Linux.

Hardware

I'm using a Raspberry Pi 2 Model B and PiCAN2 CAN-Bus board for Raspberry Pi 2 to connect to a CAN bus.

Software

The Raspberry Pi runs Raspbian.

Configuration

Update /boot/config.txt with

dtparam=spi=on 
dtoverlay=mcp2515-can0-overlay,oscillator=16000000,interrupt=25 
dtoverlay=spi-bcm2835-overlay

and reboot.

After phyiscally connecting to the CAN bus, you have to set up the can network interface for a specific bitrate, i.e. 50 kB

sudo ip link set can0 up type can bitrate 50000

Running ifconfig should now include the can0 interface.

Test your configuration

You should test if you actually receive data from the CAN bus. You can either use the candump tool from the can-utils or a simple reimplementation under cmd/candump.go.

Either way you will see something like this

> go run $GOSRC/github.com/FabianPetersen/can/cmd/candump.go -if can0

can0 100  [6] 20 83 0C 00 67 29        ' ...g)'
can0 701  [1] 05                       '.'

Usage

Setup the CAN bus

bus, _ := can.NewBusForInterfaceWithName("can0")
bus.ConnectAndPublish()

Send a CAN frame

frm := can.Frame{
	ID:     0x701,
	Length: 1,
	Flags:  0,
	Res0:   0,
	Res1:   0,
	Data:   [8]uint8{0x05},
}

bus.Publish(frm)

Receive a CAN frame

bus.SubscribeFunc(handleCANFrame)

func handleCANFrame(frm can.Frame) {    
    ...
}

There is more to learn from the documentation.

Contact

Matthias Hochgatterer

Github: https://github.com/brutella

Twitter: https://twitter.com/brutella

License

can is available under the MIT license. See the LICENSE file for more info.

Documentation

Index

• Constants
• Variables
• func Marshal(frm Frame) (b []byte, err error)
• func Unmarshal(b []byte, frm *Frame) (err error)
• func Wait(bus *Bus, id uint32, timeout time.Duration) <-chan WaitResponse
• type Bus
  • func NewBus(rwc ReadWriteCloser, ifaceName string) *Bus
  • func NewBusForInterfaceWithName(ifaceName string) (*Bus, error)
  • func (b *Bus) ConnectAndPublish() error
  • func (b *Bus) DeleteFilter() error
  • func (b *Bus) Disconnect() error
  • func (b *Bus) Publish(frame Frame) error
  • func (b *Bus) PublishLocal(frame Frame)
  • func (b *Bus) PublishMinDuration(frame Frame, min time.Duration) error
  • func (b *Bus) Reconnect() error
  • func (b *Bus) SetBlockFilter(diallowedIds []uint32) error
  • func (b *Bus) SetPassFilter(allowedIds []uint32) error
  • func (b *Bus) Subscribe(handler Handler)
  • func (b *Bus) SubscribeFunc(fn HandlerFunc)
  • func (b *Bus) Unsubscribe(handler Handler)
• type Frame
• type Handler
  • func NewHandler(fn HandlerFunc) Handler
• type HandlerFunc
• type ReadWriteCloser
  • func NewReadWriteCloser(rwc io.ReadWriteCloser) ReadWriteCloser
  • func NewReadWriteCloserForInterface(i *net.Interface) (ReadWriteCloser, error)
• type Reader
• type WaitResponse
• type Writer

Constants

const (
	// MaxFrameDataLength defines the max length of a CAN data frame defined in ISO 11898-1.
	MaxFrameDataLength = 8
	// MaxExtFrameDataLength defines the max length of an CAN extended data frame defined in ISO ISO 11898-7.
	MaxExtFrameDataLength = 64
)

Variables

var ErrorKernelFilterNotSupported = errors.New("not possible to set kernel filter")

ErrorKernelFilterNotSupported is returned if the socket attribute is 0. Then the method setsockopt can't be called.

var ErrorKernelFilterTooMany = errors.New("too many kernel filters")

Functions

func Marshal

func Marshal(frm Frame) (b []byte, err error)

Marshal returns the byte encoding of frm.

func Unmarshal

func Unmarshal(b []byte, frm *Frame) (err error)

Unmarshal parses the bytes b and stores the result in the value pointed to by frm.

func Wait

func Wait(bus *Bus, id uint32, timeout time.Duration) <-chan WaitResponse

Wait returns a channel, which receives a frame or an error, if the frame with the expected id didn't arrive on time.

Types

type Bus

type Bus struct {
	// contains filtered or unexported fields
}

Bus represents the CAN bus. Handlers can subscribe to receive frames. Frame are sent using the *Publish* method.

func NewBus

func NewBus(rwc ReadWriteCloser, ifaceName string) *Bus

NewBus returns a new CAN bus.

func NewBusForInterfaceWithName

func NewBusForInterfaceWithName(ifaceName string) (*Bus, error)

NewBusForInterfaceWithName returns a bus from the network interface with name ifaceName.

func (*Bus) ConnectAndPublish

func (b *Bus) ConnectAndPublish() error

ConnectAndPublish starts handling CAN frames to publish them to handlers.

func (*Bus) DeleteFilter

func (b *Bus) DeleteFilter() error

DeleteFilter deltes all kernel filter.

func (*Bus) Disconnect

func (b *Bus) Disconnect() error

Disconnect stops handling CAN frames.

func (*Bus) Publish

func (b *Bus) Publish(frame Frame) error

Publish publishes a frame on the bus.

Frames published with the Publish methods are not received by handlers.

func (*Bus) PublishLocal

func (b *Bus) PublishLocal(frame Frame)

PublishLocal publishes a frame to handlers

Frames published with the PublishLocal method are ONLY received by handlers.

func (*Bus) PublishMinDuration

func (b *Bus) PublishMinDuration(frame Frame, min time.Duration) error

func (*Bus) Reconnect

func (b *Bus) Reconnect() error

func (*Bus) SetBlockFilter

func (b *Bus) SetBlockFilter(diallowedIds []uint32) error

SetFilter set's can filter on kernel level. This has the advantage that the application is doesn't need to receive all frames to filter the interesting out.

func (*Bus) SetPassFilter

func (b *Bus) SetPassFilter(allowedIds []uint32) error

SetFilter set's can filter on kernel level. This has the advantage that the application is doesn't need to receive all frames to filter the interesting out.

func (*Bus) Subscribe

func (b *Bus) Subscribe(handler Handler)

Subscribe adds a handler to the bus.

func (*Bus) SubscribeFunc

func (b *Bus) SubscribeFunc(fn HandlerFunc)

SubscribeFunc adds a function as handler.

func (*Bus) Unsubscribe

func (b *Bus) Unsubscribe(handler Handler)

Unsubscribe removes a handler.

type Frame

type Frame struct {
	// bit 0-28: CAN identifier (11/29 bit)
	// bit 29: error message flag (ERR)
	// bit 30: remote transmision request (RTR)
	// bit 31: extended frame format (EFF)
	ID     uint32
	Length uint8
	Flags  uint8
	Res0   uint8
	Res1   uint8
	Data   [MaxFrameDataLength]uint8
}

Frame represents a standard CAN data frame

type Handler

type Handler interface {
	Handle(frame Frame)
}

The Handler interfaces defines a method to receive a frame.

func NewHandler

func NewHandler(fn HandlerFunc) Handler

NewHandler returns a new handler which calls fn when a frame is received.

type HandlerFunc

type HandlerFunc func(frame Frame)

HandlerFunc defines the function type to handle a frame.

type ReadWriteCloser

type ReadWriteCloser interface {
	Reader
	Writer

	io.Closer
	// contains filtered or unexported methods
}

The ReadWriteCloser interface combines the Reader and Writer and `io.Closer` interface.

func NewReadWriteCloser

func NewReadWriteCloser(rwc io.ReadWriteCloser) ReadWriteCloser

NewReadWriteCloser returns a ReadWriteCloser for an `io.ReadWriteCloser`.

func NewReadWriteCloserForInterface

func NewReadWriteCloserForInterface(i *net.Interface) (ReadWriteCloser, error)

type Reader

type Reader interface {
	io.Reader
	ReadFrame(*Frame) error
}

The Reader interface extends the `io.Reader` interface by method to read a frame.

type WaitResponse

type WaitResponse struct {
	Frame Frame
	Err   error
}

A WaitResponse encapsulates the response of waiting for a frame.

type Writer

type Writer interface {
	io.Writer
	WriteFrame(Frame, time.Duration) error
}

The Writer interface extends the `io.Writer` interface by method to write a frame.