Gruppo Meteo/CanBus

Da raspibo.
Jump to navigation Jump to search

estendere un bus I2C

https://www.nxp.com/docs/en/data-sheet/PCA9615.pdf https://www.sparkfun.com/products/14589

rs-485 vs can bus

Can Bus

Overview

The CAN bus is an ISO standard bus originally developed for vehicles. It manages the Chassis Electrical System Control and is responsible for critical activities like engine electrical, and skid control. This system is also used to provide vehicle diagnostic information for maintenance. A multi-star configuration seems typical of this bus with a primary bus line that branches into sub bus lines at its extremities then attaches to multiple device nodes. Differential voltage is applied over twisted pair at 1.5 to 2.5V and 2.5 to 3.5V for noise resistant signaling. Bit rates up to 1 Mbit/s are possible at network lengths below 40 m. Decreasing the bit rate allows longer network distances (e.g., 500 m at 125 kbit/s). (Jeremiah J. Flerchinger Source) Controllers supporting CAN FD, an enhanced CAN version with frames up to 64 byte and bit rates up to 4 Mbit/s, will be available in the second half of 2014. A can4linux version supportig CAN FD on a IFI CAN is ready to be used.

CAN message filtering: This library use 32 bit IDMASK filtering

This is a good explanation of how mask and ID are handled in STM32 devices https://schulz-m.github.io/2017/03/23/stm32-can-id-filter/ https://community.st.com/s/question/0D50X00009XkfSlSAJ/can-filters More around standard and extended ID http://www.copperhilltechnologies.com/can-bus-guide-extended-can-protocol/

Standard ID have a value between 0 and 0x7FF Extended ID have a value between 0 and 0x1FFFFFFF

A CANBUS B frame (extended) consists of a four byte header (containing a 29-bit identifier), followed by up to 8 data bytes. A receiving node would examine the identifier to decide if it was relevant (e.g. waiting for a frame with ID 00001567 which contains data to switch on or off a motor). It could do this via software (using a C if or case statement); in practice the Canbus interface contains firmware to carry out this task using the acceptance filter and mask value to filter out unwanted messages. The filter mask is used to determine which bits in the identifier of the received frame are compared with the filter If a mask bit is set to a zero, the corresponding ID bit will automatically be accepted, regardless of the value of the filter bit. If a mask bit is set to a one, the corresponding ID bit will be compare with the value of the filter bit; if they match it is accepted otherwise the frame is rejected.

Default this laibrary accept any frame e.g. no filters are applied set filter to 0 set mask to 0

Example 1. we wish to accept only frames with ID of 00001567 (hexadecimal values) set filter to 00001567 set mask to 1FFFFFFF when a frame arrives its ID is compared with the filter and all bits must match; any frame that does not match ID 00001567 is rejected

Example 2. we wish to accept only frames with IDs of 00001560 thru to 0000156F set filter to 00001560 set mask to 1FFFFFF0 when a frame arrives its ID is compared with the filter and all bits except bits 0 to 3 must match; any frame other frame is rejected

Example 3. we wish to accept only frames with IDs of 00001560 thru to 00001567 set filter to 00001560 set mask to 1FFFFFF8

when a frame arrives its ID is compared with the filter and all bits except bits 0 to 2 must match; any frame other frame is rejected

Library filter function: bool setFilter( uint32_t FilterID, uint32_t FilterMask, uint8_t FilterBank, bool IDStdOrExt );

Please read the links to figure out FilterID and FilterMask FilterBank have to be defined pr. CAN interface, 0 to 13 handle Can1 message filters and 14 to 27 handle Can1 message filters You alway have to start with the default filter e.g. 0 for Can1 and 14 for Can2 as they by default is set to allow all messages StdOrExt define ID type, default is standard

Example: We would like to recive all CAN1 messages for std ID within range 0x400 thru to 0x40f Can1.setFilter( 0x400, 0x7f0, 0, IDStd );

CAN-FD

The CAN-FD protocol (CAN with flexible data-rate) is an extension of the classical CAN (CAN 2.0) protocol.CAN‑FD is the CAN 2.0 successor. It efficiently supports distributed real-time control with a very high-level ofsecurity. CAN-FD was developed by Bosch and standardized as ISO 11898-1:2015 (suitable for industrial,automotive and general embedded communications)

Improvements and benefits of CAN-FD over CAN 2.0The CAN-FD development responds to the need of communication networks that require higher bandwidth. Thisneed is fulfilled by the CAN-FD having up to 64 bytes per frame and by its possibility to increase the bitrate to upto eight times faster during the data phase, and to go back to a normal bitrate during the second arbitration phase.The data transfer integrity is ensured by:

  • a CRC used to checksum a payload of up to 16 bytes based on 17 stage polynomial
  • a 21-stage polynomial used to checksum the payload between 16 and 64 bytes

CAN-FD featuresMain features of the CAN-FD protocol are listed below:

  • Compatibility with the CAN protocol: CAN-FD node is able to send/receive CAN messages according toISO 11898-1
  • Error-checking improvement, based on checksum field up to CRC 21 bits
  • Prioritization of messages
  • Guarantee of latency times
  • Configuration flexibility
  • Multicast reception with time synchronization
  • System-wide data consistency up to 64 bytes per message
  • Multimaster
  • Error detection and signaling
  • Distinction between temporary errors and permanent failures of nodes and autonomous switching off ofdefect nodes

can-fd-light

Can bus in Linux

Can bus python


hardware

CAN SPI mcp2515

SLCAN

STM32

https://github.com/r-map/rmap/blob/master/platformio/test/canbus-exocan/schematic.png

Can stm32.jpg

exocan

https://github.com/r-map/rmap/blob/master/platformio/test/canbus-exocan/src/bpCanBlinkInterrupt.ino

STM32CAN

CanOpen

CANopen is a communication protocol and device profile specification for embedded systems used in automation. In terms of the OSI model, CANopen implements the layers above and including the network layer. The CANopen standard consists of an addressing scheme, several small communication protocols and an application layer defined by a device profile.

CANdevStudio

https://github.com/GENIVI/CANdevStudio


SAE_J1939

https://en.wikipedia.org/wiki/SAE_J1939

UAVCAN

What is UAVCAN?

UAVCAN is an open lightweight protocol designed for reliable intravehicular communication in aerospace and robotic applications over CAN bus, Ethernet, and other robust transports. It is created to address the challenge of deterministic on-board data exchange between systems and components of next-generation intelligent vehicles: manned and unmanned aircraft, spacecraft, robots, and cars.

https://uavcan.org/ https://uavcan.org/specification/UAVCAN_Specification_v1.0-beta.pdf

https://forum.uavcan.org/t/automatic-configuration-of-port-identifiers/840/3

libreria per arduino

https://github.com/107-systems/107-Arduino-MCP2515


Applicazioni Px4

https://dev.px4.io/master/en/uavcan/

pyuavcan

pyuavcan sub --transport "pyuavcan.transport.can.CANTransport(can.media.socketcan.SocketCANMedia('can0',8),None)" uavcan.node.Heartbeat.1.0


==

UAVCAN libreria c++ semplificata per arduino

UAVCAN library for Espressif microcontrollers. (Arduino SDK)

https://github.com/JediJeremy/libuavesp


LIBCANARD UAVCAN library for STM32 microcontrollers. (Arduino SDK)

https://github.com/r-map/rmap/blob/master/platformio/test/uavcan-v1/src/example.ino

Estratto da "https://www.raspibo.org/wiki/index.php?title=Gruppo_Meteo/CanBus&oldid=7306"