'''Come debuggare con AVR Dragon su arduino'''

WARNING

It is possible, using the tools discussed here to either ‘brick’ your processor or physically destroy it. This also includes your AVR Dragon. Make sure you double and triple check all connections BEFORE you turn on any power and make sure you disconnect the power BEFORE making any wiring changes.

I can not be held responsible for your errors in skills or judgement.

= Microduino e platformio =

== materiali necessari ==
hardware:
* Microduino core/core+
* AVR Dragon (sostituito da https://www.mouser.it/new/microchip/microchip-atmel-ice-kit/ ?)
* cavi ...
* un pc

https://atmega32-avr.com/wp-content/uploads/2012/11/AVR_Dragon_Manual_User_Guide.pdf
https://ww1.microchip.com/downloads/en/devicedoc/atmel-42723-avr-dragon_userguide.pdf

software:
* un sistema operativo serio (Linux)
* platformio
* avrdude
* avarice
* gdb
* ddd

== Operazioni sistemistiche preliminari ==

Queste operazioni sono necessarie per rendere disponibile AVR Dragon agli utenti abilitati (quelli del gruppo '''dialout'''); altrimenti sarà solo root a poter agire.

Istruzioni valide per Fedora, per altro non so.

Da utente root:

editare il file /etc/udev/rules.d/50-avrdragon.rules e inserire:

SUBSYSTEM=="usb", ATTR{idVendor}=="03eb", ATTR{idProduct}=="2107", GROUP="dialout", MODE="0660"

oppure utilizzare il default per platformio:

https://docs.platformio.org/en/latest/faq.html#platformio-udev-rules

eseguire:

service systemd-udevd restart

== Collegamenti ==
'''ISP:'''
In System Programming using SPI is well suited for programming devices soldered onto external target boards. This section explains how to connect the Atmel AVR Dragon to SPI program an external target. The SPI lines are equipped with level converters that automatically will level shift the AVR Dragon signals to the target board voltage.

It is recommended that a 6-pin header connector with 2.54mm (100 MIL) spacing is placed on the target board to allow easy access to the SPI programming interface. The following pinout should be used.

6pin Header Connector with 2.54mm (100 MIL) spacing
http://www.atmel.no/webdoc/avrdragon/images/ISPHEADER.jpg

[[File:jtag_isp_schema.png]]

'''Jtag:'''

http://support.atmel.no/knowledgebase/avrstudiohelp/mergedProjects/AVRDragon/JTAG_schematic_target.JPG

There are only 7 connections needed and these are as follows:

{| border="1"
|MicroduinoPin
|Signal
|Dragon Jtag
|I/O
|Description
|-
|5v/3.3v
| +5v/+3.3v
|4
|Output
|5v Supply from Arduino
|-
|GND
|GND
|2 or 10 (either will do)
| -
|Ground reference
|-
|D19 (no upin27, in extension for core+)
|TCK
|1
|Input
|Test Clock, clock signal from AVR Dragon to target JTAG port
|-
|D18 (no upin27, in extension for core+)
|TMS
|5
|Input
|Test Mode Select, mode select signal from AVR Dragon to target JTAG port
|-
|D17 (no upin27, in extension for core+)
|TDO
|3
|Output
|Test Data Output, data signal from target JTAG port to AVR Dragon
|-
|D16 (no upin27, in extension for core+)
|TDI
|9
|Input
|Test Data Input, data signal from AVR Dragon to target JTAG port
|-
|reset
|RST
|6
|
|Reset
|}

Note: These pin numbers refer to the shield pin numbers of the Microduino core+ and not to the pins on the processor.
Note: Although the +5v are joined, you will still need to provide power to your Mega board by any of the normal methods. The sole purpose of the +5v connection is to correctly configure the level shifters/converts used by the Dragon to process signals between the boards. If you are using a 3.3v Dragon, then it is important that you connect the +5v signal to the +3.3v signal instead. Otherwise there is a pretty good chance you will destroy your Mega in a few seconds. This signal can not power the Mega from the Dragon!

Note: Power up your Mega board before the Dragon.

Note: Make sure there are no other connections to pine D16, D17, D18 or D19 on the Microduino, other than those to the Dragon.

[[File:jtag_isp.png]]

== Fuse Setting ==

http://www.codingwithcody.com/2011/04/arduino-default-fuse-settings/

'''default Arduino '''

* Low Fuse 0xFF
* High Fuse 0xDE
* Extended Fuse 0xFD

you need to enable the OCDEN and JTAGEN fuses

Per il calcolo si può utilizzare:
http://www.engbedded.com/fusecalc/

da cui si ottiene:
* Low Fuse 0xFF
* High Fuse 0x1E
* Extended Fuse 0xFD

quindi:

avrdude -c dragon_isp -P usb -p m1284p -U lfuse:w:0xFF:m -U hfuse:w:0x1E:m -U efuse:w:0xFD:m

Quando avari finito tutto reimpostare i valori di dafault:

avrdude -c dragon_isp -P usb -p m1284p -U lfuse:w:0xFF:m -U hfuse:w:0xDE:m -U efuse:w:0xFD:m

== Sessione di debug ==

Dopo aver compilato con le opzioni di debug determinati dall'opzione
build_type = debug

in platformio.ini

pio run -t upload

eseguire avarice che rimane in attesa di connessione da parte di gdb:

avarice --dragon :4242

poi lanciare il debugger:

~/.platformio/packages/toolchain-atmelavr/bin/avr-gdb firmware.elf

'''oppure ddd'''
ddd --debugger ~/.platformio/packages/toolchain-atmelavr/bin/avr-gdb .pio/build/644pa16m/firmware.elf

At the (gdb) prompt, tell GDB to connect to AVaRICE:

(gdb) target remote localhost:4242

This will stop the program running on the APM and tell you where it stopped:

Remote debugging using localhost:4242
0x00002992 in AP_GPS_NMEA::read (this=0x8007aa)
at /Volumes/Data/Users/msmith/work/Mike/ArduPilot/Sketchbook/libraries/AP_GPS/AP_GPS_NMEA.cpp:72
72 numc = _port->
available();
(gdb)

Use the ‘continue’ command to start the program running again, and hit control-C to stop it once more.

== Come far tornare l'arduino come un vero arduino ==

avrdude -c dragon_isp -P usb -p m1284p -e -u -U lock:w:0xFF:m -U lfuse:w:0xFF:m -U hfuse:w:0xDE:m -U efuse:w:0xFD:m
avrdude -c dragon_isp -P usb -p m1284p -V -U flash:w:optiboot_atmega1280.hex
avrdude -c dragon_isp -P usb -p m1284p -U lock:w:0x0F:m

The first command unlocks the bootloader section and sets the fuses.
The second writes the bootloader to the flash memory.
And the third locks the bootloader section again.

= Arduino mega2560 =

== materiali necessari ==
hardware:
* arduino mega2560
* AVR Dragon
* cavi ...
* un pc

software:
* un sistema operativo serio (Linux)
* toolchain gcc per avr
* avrdude
* avarice
* gdb
* ddd

== Operazioni sistemistiche preliminari ==

Queste operazioni sono necessarie per rendere disponibile AVR Dragon agli utenti abilitati (quelli del gruppo '''dialout'''); altrimenti sarà solo root a poter agire.

Istruzioni valide per Fedora, per altro non so.

Da utente root:

editare il file /etc/udev/rules.d/50-avrdragon.rules e inserire:

SUBSYSTEM=="usb", ATTR{idVendor}=="03eb", ATTR{idProduct}=="2107", GROUP="dialout", MODE="0660"

eseguire:

service systemd-udevd restart

== Collegamenti ==
'''ISP:'''
In System Programming using SPI is well suited for programming devices soldered onto external target boards. This section explains how to connect the Atmel AVR Dragon to SPI program an external target. The SPI lines are equipped with level converters that automatically will level shift the AVR Dragon signals to the target board voltage.

It is recommended that a 6-pin header connector with 2.54mm (100 MIL) spacing is placed on the target board to allow easy access to the SPI programming interface. The following pinout should be used.

6pin Header Connector with 2.54mm (100 MIL) spacing
http://www.atmel.no/webdoc/avrdragon/images/ISPHEADER.jpg

Questo la disposizione dei pin sulla board Arduino
http://arduino-info.wikispaces.com/file/view/Mega2560_R3_Label-small-v2%20%282%29.png/471429496/800x526/Mega2560_R3_Label-small-v2%20%282%29.png

il collegamento ISP una volta capito è facile: l'ordine è il medesimo, basta trovare il pin 1 del connettore.

link:
http://www.atmel.no/webdoc/avrdragon/avrdragon.isp_description.html
http://arduino-info.wikispaces.com/MegaQuickRef

'''Jtag:'''

http://support.atmel.no/knowledgebase/avrstudiohelp/mergedProjects/AVRDragon/JTAG_schematic_target.JPG

There are only 7 connections needed and these are as follows:

{| border="1"
|arduinoPin
|Signal
|Dragon Jtag
|I/O
|Description
|-
|5v
| +5v
|4
|Output
|5v Supply from Arduino
|-
|GND
|GND
|2 or 10 (either will do)
| -
|Ground reference
|-
|analog in 4
|TCK
|1
|Input
|Test Clock, clock signal from AVR Dragon to target JTAG port
|-
|analog in 5
|TMS
|5
|Input
|Test Mode Select, mode select signal from AVR Dragon to target JTAG port
|-
|analog in 6
|TDO
|3
|Output
|Test Data Output, data signal from target JTAG port to AVR Dragon
|-
|analog in 7
|TDI
|9
|Input
|Test Data Input, data signal from AVR Dragon to target JTAG port
|-
|reset
|RST
|6
|
|Reset
|}

Note: These pin numbers refer to the shield pin numbers of the Arduino Mega2560 and not to the pins on the processor.
Note: Although the +5v are joined, you will still need to provide power to your Mega board by any of the normal methods. The sole purpose of the +5v connection is to correctly configure the level shifters/converts used by the Dragon to process signals between the boards. If you are using a 3.3v Dragon, then it is important that you connect the +5v signal to the +3.3v signal instead. Otherwise there is a pretty good chance you will destroy your Mega in a few seconds. This signal can not power the Mega from the Dragon!

Note: Power up your Mega board before the Dragon.

Note: Make sure there are no other connections to pine 4, 5, 6 or 7 on the Mega, other than those to the Dragon.

== Fuse Setting ==

http://www.codingwithcody.com/2011/04/arduino-default-fuse-settings/

'''default Arduino Mega 2560 '''

* Low Fuse 0xFF
* High Fuse 0xD8
* Extended Fuse 0xFD

you need to enable the OCDEN and JTAGEN fuses

Per il calcolo si può utilizzare:
http://www.engbedded.com/fusecalc/

da cui si ottiene:
-U lfuse:w:0xff:m -U hfuse:w:0x18:m -U efuse:w:0xfd:m

quindi:

avrdude -c dragon_isp -P usb -p atmega2560 -U lfuse:w:0xff:m -U hfuse:w:0x18:m -U efuse:w:0xfd:m

Quando avari finito tutto reimpostare i valori di dafault:

avrdude -c dragon_isp -P usb -p atmega2560 -U lfuse:w:0xff:m -U hfuse:w:0xf8:m -U efuse:w:0xfd:m

== Sessione di debug ==

Dopo aver compilato (io uso ino) con l'opzione -g e preferibilmente con -g2 -O0 caricare il programma usanto l'interfaccia jstag e il Dragon:

avrdude -p atmega2560 -c dragon_isp -P usb -U flash:w:.build/mega2560/firmware.hex:i

eseguire avarice che rimane in attesa di connessione da parte di gdb:

avarice --dragon :4242

poi lanciare il debugger:
avr-gdb .build/mega2560/firmware.elf

'''attenzione !! ddd non funziona e chissà perchè'''
ddd --debugger avr-gdb .build/mega2560/firmware.elf

At the (gdb) prompt, tell GDB to connect to AVaRICE:

(gdb) target remote localhost:4242

This will stop the program running on the APM and tell you where it stopped:

Remote debugging using localhost:4242
0x00002992 in AP_GPS_NMEA::read (this=0x8007aa)
at /Volumes/Data/Users/msmith/work/Mike/ArduPilot/Sketchbook/libraries/AP_GPS/AP_GPS_NMEA.cpp:72
72 numc = _port->
available();
(gdb)

Use the ‘continue’ command to start the program running again, and hit control-C to stop it once more.

== Come far tornare l'arduino come un vero arduino ==

avrdude -c dragon_isp -P usb -p atmega2560 -e -u -U lock:w:0x3F:m -U efuse:w:0xFD:m -U hfuse:w:0xD8:m -U efuse:w:0xFF:m
avrdude -c dragon_isp -P usb -p atmega2560 -V -U flash:w:/usr/share/arduino/hardware/arduino/bootloaders/stk500v2/stk500boot_v2_mega2560.hex
avrdude -c dragon_isp -P usb -p atmega2560 -U lock:w:0x0F:m

The first command unlocks the bootloader section and sets the fuses.
The second writes the bootloader to the flash memory.
And the third locks the bootloader section again.

File:Jtag isp.png

2021-12-11T13:20:32Z

Pat1:

2020-10-28T21:13:46Z

Pat1:

= 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 =
* https://www.maximintegrated.com/content/dam/files/design/technical-documents/white-papers/can-wp.pdf

= 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.

* https://jeelabs.org/2018/canbus-intro/
* https://www.engineersgarage.com/article_page/can-protocol-understanding-the-controller-area-network-protocol/

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 ===
* https://www.st.com/content/st_com/en/about/events/events.html/can-fd-light.html

== Can bus in Linux ==
* https://elinux.org/CAN_Bus
* https://elinux.org/Bringing_CAN_interface_up

== Can bus python ==

* https://python-can.readthedocs.io/en/master/

== hardware ==

== CAN SPI mcp2515 ==
* https://www.electronicshub.org/arduino-mcp2515-can-bus-tutorial/
* https://www.ebay.it/itm/162281092785

== SLCAN ==
* http://www.can232.com/docs/canusb_manual.pdf
* https://github.com/r-map/rmap/blob/master/platformio/test/slcan/src/slcan.ino

==== STM32 ====
* https://www.st.com/content/ccc/resource/training/technical/product_training/de/ee/37/c6/60/9c/45/a5/STM32L4_Peripheral_CAN.pdf/files/STM32L4_Peripheral_CAN.pdf/jcr:content/translations/en.STM32L4_Peripheral_CAN.pdf
* https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=&ved=2ahUKEwj0iNHpn9PsAhVPDuwKHVh-AiIQFjACegQIAxAC&url=https%3A%2F%2Fwww.st.com%2Fresource%2Fen%2Freference_manual%2Fcd00171190-stm32f101xx-stm32f102xx-stm32f103xx-stm32f105xx-and-stm32f107xx-advanced-arm-based-32-bit-mcus-stmicroelectronics.pdf&usg=AOvVaw2kF0T1D3TzsgvgnX7fvMku
* https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=&ved=2ahUKEwjaod2im9PsAhURDewKHYY3BvMQFjABegQIBxAC&url=https%3A%2F%2Fwww.st.com%2Fresource%2Fen%2Fapplication_note%2Fdm00625700-fdcan-peripheral-on-stm32-devices-stmicroelectronics.pdf&usg=AOvVaw3jMF7ihgDGaclOGo6nlqEh
* https://thecodeprogram.com/stm32f4---std-periphals-can-bus-with-can-interrupts
* MCP2551 CAN transceiver IC

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

[[File:can_stm32.jpg]]

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

==== STM32CAN ====
* https://github.com/J-f-Jensen/libraries/tree/master/STM32CAN
* https://github.com/r-map/rmap/blob/master/platformio/test/CAN_TrafficSnooper/src/CAN_TrafficSnooper.ino

= CANdevStudio =
* https://github.com/GENIVI/CANdevStudio

= CanOpen =
* https://en.wikipedia.org/wiki/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.

* https://github.com/curvi/CANopen

= 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 ==
* https://github.com/107-systems/107-Arduino-UAVCAN

== 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

Gruppo Meteo/CanBus

2020-10-28T21:11:34Z

Pat1: /* stm32duino */

= 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 =
* https://www.maximintegrated.com/content/dam/files/design/technical-documents/white-papers/can-wp.pdf

= 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.

* https://jeelabs.org/2018/canbus-intro/
* https://www.engineersgarage.com/article_page/can-protocol-understanding-the-controller-area-network-protocol/

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 ===
* https://www.st.com/content/st_com/en/about/events/events.html/can-fd-light.html

== Can bus in Linux ==
* https://elinux.org/CAN_Bus
* https://elinux.org/Bringing_CAN_interface_up

== Can bus python ==

* https://python-can.readthedocs.io/en/master/

== hardware ==

== CAN SPI mcp2515 ==
* https://www.electronicshub.org/arduino-mcp2515-can-bus-tutorial/
* https://www.ebay.it/itm/162281092785

== SLCAN ==
* http://www.can232.com/docs/canusb_manual.pdf
* https://github.com/r-map/rmap/blob/master/platformio/test/slcan/src/slcan.ino

==== STM32 ====
* https://www.st.com/content/ccc/resource/training/technical/product_training/de/ee/37/c6/60/9c/45/a5/STM32L4_Peripheral_CAN.pdf/files/STM32L4_Peripheral_CAN.pdf/jcr:content/translations/en.STM32L4_Peripheral_CAN.pdf
* https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=&ved=2ahUKEwj0iNHpn9PsAhVPDuwKHVh-AiIQFjACegQIAxAC&url=https%3A%2F%2Fwww.st.com%2Fresource%2Fen%2Freference_manual%2Fcd00171190-stm32f101xx-stm32f102xx-stm32f103xx-stm32f105xx-and-stm32f107xx-advanced-arm-based-32-bit-mcus-stmicroelectronics.pdf&usg=AOvVaw2kF0T1D3TzsgvgnX7fvMku
* https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=&ved=2ahUKEwjaod2im9PsAhURDewKHYY3BvMQFjABegQIBxAC&url=https%3A%2F%2Fwww.st.com%2Fresource%2Fen%2Fapplication_note%2Fdm00625700-fdcan-peripheral-on-stm32-devices-stmicroelectronics.pdf&usg=AOvVaw3jMF7ihgDGaclOGo6nlqEh
* https://thecodeprogram.com/stm32f4---std-periphals-can-bus-with-can-interrupts
* MCP2551 CAN transceiver IC

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

[[File:can_stm32.jpg]]

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

==== STM32CAN ====
* https://github.com/J-f-Jensen/libraries/tree/master/STM32CAN
* https://github.com/r-map/rmap/blob/master/platformio/test/CAN_TrafficSnooper/src/CAN_TrafficSnooper.ino

= CanOpen =
* https://en.wikipedia.org/wiki/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.

* https://github.com/curvi/CANopen

= 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 ==
* https://github.com/107-systems/107-Arduino-UAVCAN

== 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

2020-10-26T17:48:12Z

Pat1: /* STM32 */

Gruppo Meteo/CanBus

2020-10-26T17:12:20Z

Pat1:

Gruppo Meteo/CanBus

2020-10-26T16:41:35Z

Pat1: Creata pagina con '= estendere un bus I2C = https://www.nxp.com/docs/en/data-sheet/PCA9615.pdf https://www.sparkfun.com/products/14589 = Can Bus = Overview The CAN bus is an ISO standard bus o...'

Gruppo Meteo/RFC-rmap

2020-10-07T13:43:56Z

Pat1:

Versione attuale pubblicata qui [https://doc.rmap.cc/rmap_rfc/rfc.html RMAP RFC]

Discussione:Gruppo Meteo/RFC-rmap

2020-10-07T13:41:24Z

Pat1: Pat1 ha spostato la pagina Discussione:Gruppo Meteo/RFC-rmap a Discussione:Gruppo Meteo/RFC-rmap obsolete: pubblicazione su https://doc.rmap.cc/rmap_rfc/rfc.html

#RINVIA [[Discussione:Gruppo Meteo/RFC-rmap obsolete]]