The Basics of CAN Bus: A Beginner’s Guide to Understanding the CAN Protocol – Part 2

This is a continuation from Part 1. We’ll be setting up a basic CAN bus network with basic components.

BTT Octopus and EBB42 without U2C Basic Setup

Note: Assuming Klipper git was previously installed at ~/klipper. Please note there are other methods to use CAN bus without BTT U2C, but will involve additional hardware at this time.

Hardware being used

  • Octopus (STM32F446)
  • EBB42 V1.2 (STM32G0B1)
  • 1x 120Ω resistor (or any resistors that add up to 120Ω in series, like 3x 40Ω, 2x 60Ω, or 100Ω & 20Ω)

Power Cables

EBB42 V1.2 has maximum of 5A pull. The printer environment we’ll be using is a Voron 2.4r2 and it uses 24V. We estimate maximum 8 ft of cable from the power source. After using two online calculators provided by https://www.omnicalculator.com/physics/dc-wire-size and https://www.wirebarn.com/Wire-Calculator-_ep_41.html with using 6 Amps for higher tolerance, 18 AWG stranded copper cable would work. Unfortunately, we didn’t have 18 AWG stranded copper cable on hand, thus we’ll be using stranded 16 AWG Aluminum cable for power delivery that we had in our inventory.

CAN BUS Signal Cables

For CAN bus, it is recommended to use twisted data bus to enhance its’ high noise immunity and common-mode rejection. We’ll be using a twisted pair from a working CAT5e stranded cable. CAT5e cable contains 4 twisted pairs of cable.

Wiring

Above image is a typical CAN bus network, below its what logically it’ll look like.

We choose blue and blue/white stranded pair from the CAT5e cable and solid blue will be CAN high. We soldered one end with the resistor and a twisted cable with a RJ11 end (used this external github reference). The RJ11 end can be plugged into the BTT Octopus V1.1.After installing the twisted pair and power cable into the cable chains, we terminated the BTT EBB42 male Molex connector with the diagram provided from Big Tree Tech at this external github reference. We also plugged in the 120R(Ω) jumper on the EBB42 as we weren’t planning on adding additional nodes/devices to the CAN bus network.

Octopus Steps

IMPORTANT NOTICE: We’re currently running into an issue where we cannot re-flash our Octopus board via DFU mode; but Klipper can be re-flashed via SD-Card (rename klipper.bin to firmware.bin on SD-Card). We weren’t able to flash CanBoot to Octopus, this is usually done prior to installing Klipper firmware; these instructions aren’t here since we couldn’t reproduce and test it. We recommend trying to install CanBoot as your bootloader on both devices as it would simplify Klipper updates.

We are using a STM32F446 Octopus V1.1 Board. Please check the MCU of your Octopus as your settings may be different.

Klipper Installation

  1. Run the following commands:
cd ~/klipper
make menuconfig
  1. Set the following settings:
[*] Enable extra low-level configuration options
Micro-controller Architecture (STMicroelectronics STM32)
Processor Model (STM32F446)
Bootloader offset (32KiB bootloader)
Clock Reference (12 MHz crystal)
Communication interface (USB to CAN bus bridge (USB on PA11/PA12)
Can Bus Interface (CAN bus (on PD0/PD1))
(500000) CAN bus speed
  1. Press q and then y.
  2. Type make and confirm no errors occurs.
  3. Our Octopus board was connected via USB, so we used:
    sudo service klipper stop
    make flash FLASH_DEVICE=/dev/serial/by-id/usb-Klipper_stm32f446xx_...
    sudo service klipper start

Raspberry Pi/Klipper Service Host Setup

We will need to setup a CAN interface for Klipper service to interact with. To confirm that the firmware has been installed, run lsusb and one of the connections should show OpenMoko, Inc Geschwister Schneider CAN adapter.

Add /etc/network/interfaces.d/can0 file with the below contents

allow-hotplug can0
iface can0 can static
bitrate 500000
up ifconfig $IFACE txqueuelen 2048

Then reboot the Raspberry Pi/Klipper service host.

EBB42 V1.2 Steps

We are using EBB42 V1.2, however a previous model version or versions have a flaw where the heater is turned on during flashing and caused fire damage. Double check your version with the manufacture and take necessary precaution steps if required.

  1. If CAN bus connection is connected to EBB, remove this CAN bus connection.
    • Important: If you skip this step, you will damage your EBB42.
  2. Place jumper on USB-C power.
  3. Plug in USB-C cable between Klipper host and EBB.
  4. Power LED should be on by this step.
  5. Hold down boot button and reset button, then release boot button.
  6. Type lsusb and hit enter.
  7. Output text should have a STM and DFU for a single USB device. After ID there will be text formatted as ####:#### this will be referred to as <uuid> in the CanBoot Install steps.

Canboot Install

  1. Run following commands:
git clone https://github.com/arksine/CanBoot
cd CanBoot
make menuconfig
  1. Match settings below:
Micro-controller Architecture (STMicroelectronics STM32)
Processor model (SMT32G0B1)
Build CanBoot deployment application (Do not Build)
Clock Reference (8 MHz crystal)
Communication interface (CAN bus (on PB0/PB1))
Application start offset (8KiB offset)
(500000) CAN bus speed
() GPIO pins to set on bootloader entry
[*]Support bootloader entry on rapid double click of reset button
[] Enable bootloader entry on button (or gpio) state
[] Enable Status LED
  1. press q and y.
  2. Type the below commands and replace <uuid> from the previous EBB42 step 6.
make
sudo dfu-util -a 0 -D ~/CanBoot/out/canboot.bin --dfuse-address 0x08000000:force:mass-erase -d <uuid>
  1. Disconnect USB-C cable and remove USB-C power jumper.
    • Important: If you skip this step, you will damage your EBB42.
  2. Reconnect CAN bus cable.

Klipper Install

These are steps involved to install Klipper on top of CanBoot for EBB42.

  1. Type the following commands:
cd ~/klipper
make menuconfig
  1. Set the following settings:
[*] Enable extra low-level configuration options
Micro-controller Architecture (STMicroelectronics STM32)
Processor Model (STM32G0B1)
Bootloader offset (8KiB bootloader)
Clock Reference (8 MHz crystal)
Communication interface (CAN bus (on PB0/PB1)
(500000) CAN bus speed
  1. Press q and y.
  2. Run the following:
make
python3 ~/CanBoot/scripts/flash_can.py -q
  1. From the previous output, there will be a line formatted like
    Detected UUID: ############, Application: CanBoot
    use the ############ portion for the <EBB UUID> going forward.
  2. There will be another UUID listed with Application: Klipper, use this for <Octopus UUID> going forward.
  3. python3 ~/CanBoot/scripts/flash_can.py -u <EBB UUID>
  4. You should get CAN Flash Success to indicate successful Klipper flashing.

Klipper Configuration

Klipper configuration will need to be modified:

  1. Edit printer.cfg.
  2. Change [mcu] section.
#serial: /dev/serial/by-id/usb-Klipper_stm34f446...
canbus_uuid: <Octopus uuid>
canbus_interface: can0
  1. Save printer.cfg.
  2. Download the example *.cfg for your EBB. For our case we downloaded bigtreetech-ebb-canbus-v1.2.cfg from https://github.com/bigtreetech/EBB and uploaded it into the Klipper configurations folder.
  3. We added [include bigtreetech-ebb-canbus-v1.2.cfg] to the top of printer.cfg.
  4. We modified bigtreetech-ebb-canbus-v1.2.cfg.
[mcu EBBCan]
#serial: /dev/serial/by-id/usb-Klipper_Klipper_firmware_12345-if00
canbus_uuid: <EBB uuid>
  1. Unfortunately, the example config file had a space after EBBCAN: <pin> in multiple locations, these spaces were removed.
  2. Since we were upgrading an existing printer, we transferred most of the [extruder] section settings as well and commented them out in klipper.cfg.

Choosing Network Patch Cable Lengths

Setting up a computer network requires careful planning, and one important decision you’ll need to make is selecting the right patch cable lengths for the job. Patch cables are used to connect devices within a rack or between different racks, and choosing the right cable length is crucial to ensuring an efficient and easy-to-troubleshoot network.

When choosing patch cable lengths, it’s important to keep them short but not too short. For instance, 6-inch patch cables are ideal for connecting devices/patch panel ports within a single rack unit (U), which is 1.75 inches tall. Longer cables will create clutter and strain on the cable. A 1-foot patch cable is usually sufficient for as many as six rack units.

However, calculating the appropriate cable length can be more complex when the path goes in different directions or depths within the rack. In such cases, you’ll need to calculate the cable length based on the total inches required for the path. For instance, if the path goes in either horizontal direction, add 19 inches to the total vertical inches, then divide by 12 inches to obtain the cable length in feet. If the path goes from the front of the rack to the back, you’ll need to add the equipment depth to the total inches before calculating the cable length in feet.

Depending on the existing rack layout, it may also be necessary to add a service loop of 2-3 feet (24-36 inches) to allow for flexibility and future maintenance. Once you’ve determined the total cable length in feet, round up to the nearest foot. In some cases, it may be necessary to round up to the nearest foot ending with 5 or 0 when there is no pre-made cable length available that matches your requirements.

By following these guidelines, you can select the appropriate patch cable length for your computer network setup. This can help ensure optimal performance, efficiency, and easy maintenance, which are crucial for a successful network.

TLDR: Fast Formulas

Total Estimated Min Length (inches) = 1.75″ * (Rack U Height to Travel) + (if destination is not directly vertical from source in same rack, 19″) + (Device depth, if going from front to back of rack, commonly 21″) + (Any service loop required)

Total Min Length (Feet) = Round Up (Total Estimated Min Length (inches)/12)

The Basics of CAN Bus: A Beginner’s Guide to Understanding the CAN Protocol – Part 1

The communication protocol, CAN bus, is used in various industries such as automotive, medical, and industrial systems. In the field of 3D printing, CAN bus has the potential to improve the printing process by connecting several components, including the main control board, extruders, and motors. CAN bususes high-speed serial communication to enable real-time communication, making it suitable for applications that require timing and synchronization.

The CAN protocol defines the way devices communicate over a CAN busnetwork, determining how data is transmitted and received, and how devices are addressed and identified. The protocol uses differential signaling to send data through two wires with equal and opposite voltage levels. The protocol can detect and correct transmission errors, ensuring reliable data transmission in noisy environments and over long distances.


Some Hardware Examples:

Main Controller Boards:

  • BigTreeTech(BTT) Octopus
  • Duet3D Main Board 6HC
  • Duet3D Main Board 6XD

Toolhead/extruders:

  • Duet 3 Tool Board 1LC
  • Duet 3 Tool Board 1HCL
  • BigTreeTech(BTT) EBB36 & EEB42 (Note: certain hardware versions may cause a fire, reach out to BTT support)
  • BigTreeTech(BTT) EBB U2C

Motors:

  • Duet 3 Expansion Board 3HC
  • Duet 3 Expansion Board 1XD

Once at least 2 CAN bus compatible components had been bought, the process of connecting them via the CAN bus network can begin. CAN bus cables are required to link all components together. Typically, these cables have four wires – two for power and two for communication. One can either purchase these cables or create them using CAT3 or higher-rated cables for the communication wires and appropriate AWG-gauge wires for the power wires if they choose to make them themselves.

After connecting the components, one needs to configure the firmware of the 3D printer to use CAN bus. This involves setting the correct baud rate, addressing scheme, and other parameters to ensure that the components can communicate effectively. Finally, one needs to test their setup to ensure that CAN bus communication is working correctly. This will involve sending commands to the printer and monitoring the responses to ensure that data is being transmitted accurately and reliably.

In case issues arise, some common issues that may occur include incorrect wiring, electrical noise, and software issues. Some resolutions to these issues, double-check all connections to ensure they are properly wired, reduce electrical noise by using shielded cables and ferrite beads, ensure the latest firmware is being used with all settings correctly configured, and ensuring correct resistance & voltage is used on CAN bus.

CAN bus enables fast and reliable communication between different components, allowing for greater control and precision in the printing process, resulting in higher-quality prints. Although implementing CAN bus in 3D printing may require additional hardware and configuration, the benefits are clear. By reducing the number of cables and simplifying the wiring of the printer, one can achieve faster printing speeds, possibly less toolhead weight, and improved reliability. Moreover, using CAN bus in 3D printing allows for scalability and expand-ability, which can accommodate future changes without requiring significant modifications to the network.

Part 2 will cover setup of a BTT Octopus and BTT EBB42 without BTT U2C….

Nate15329's Blog