3D printing marlin

What is Marlin? | Marlin Firmware

Marlin is an open source firmware for the RepRap family of replicating rapid prototypers — popularly known as “3D printers.” It was derived from Sprinter and grbl, and became a standalone open source project on August 12, 2011 with its Github release. Marlin is licensed under the GPLv3 and is free for all applications.

From the start Marlin was built by and for RepRap enthusiasts to be a straightforward, reliable, and adaptable printer driver that “just works.” As a testament to its quality, Marlin is used by several respected commercial 3D printers. LulzBot, Průša Research, Creality3D, BIQU, Geeetech, and Ultimaker are just a few of the vendors who ship a variant of Marlin. Marlin is also capable of driving CNC machines and laser engravers.

One key to Marlin’s popularity is that it runs on inexpensive 8-bit Atmel AVR micro-controllers - Marlin 2.x has added support for 32-bit boards. These chips are at the center of the popular open source Arduino/Genuino platform. The reference platforms for Marlin is an Arduino Mega2560 with RAMPS 1.4 and Re-Arm with Ramps 1.4.

As a community product, Marlin aims to be adaptable to as many boards and configurations as possible. We want it to be configurable, customizable, extensible, and economical for hobbyists and vendors alike. A Marlin build can be very small, for use on a headless printer with only modest hardware. Features are enabled as-needed to adapt Marlin to added components.

Main features

Full-featured G-code with over 150 commands
Complete G-code movement suite, including lines, arcs, and Bézier curves
Smart motion system with lookahead, interrupt-based movement, linear acceleration
Support for Cartesian, Delta, SCARA, and Core/H-Bot kinematics
Closed-loop PID heater control with auto-tuning, thermal protection, safety cutoff
Support for up to 5 extruders plus a heated printbed
LCD Controller UI with more than 30 language translations
Host-based and SD Card printing with autostart
Bed Leveling Compensation — with or without a bed probe
Linear Advance for pressure-based extrusion
Support for Volumetric extrusion
Support for mixing and multi-extruders (Cyclops, Chimera, Diamond)
Support for Filament Runout/Width Sensors
Print Job Timer and Print Counter

How Marlin Works

Marlin Firmware runs on the 3D printer’s main board, managing all the real-time activities of the machine. It coordinates the heaters, steppers, sensors, lights, LCD display, buttons, and everything else involved in the 3D printing process.

Marlin implements an additive manufacturing process called Fused Deposition Modeling (FDM) — aka Fused Filament Fabrication (FFF). In this process a motor pushes plastic filament through a hot nozzle that melts and extrudes the material while the nozzle is moved under computer control. After several minutes (or many hours) of laying down thin layers of plastic, the result is a physical object.

The control-language for Marlin is a derivative of G-code. G-code commands tell a machine to do simple things like “set heater 1 to 180°,” or “move to XY at speed F.” To print a model with Marlin, it must be converted to G-code using a program called a “slicer.” Since every printer is different, you won’t find G-code files for download; you’ll need to slice them yourself.

As Marlin receives movement commands it adds them to a movement queue to be executed in the order received. The “stepper interrupt” processes the queue, converting linear movements into precisely-timed electronic pulses to the stepper motors. Even at modest speeds Marlin needs to generate thousands of stepper pulses every second. (e.g., 80 steps-per-mm * 50mm/s = 4000 steps-per-second!) Since CPU speed limits how fast the machine can move, we’re always looking for new ways to optimize the stepper interrupt!

Heaters and sensors are managed in a second interrupt that executes at much slower speed, while the main loop handles command processing, updating the display, and controller events. For safety reasons, Marlin will actually reboot if the CPU gets too overloaded to read the sensors.

Printing Things

Modeling

While Marlin only prints G-code, most slicers only slice STL files.

Whatever you use for your CAD toolchain, as long as you can export a solid model, a slicer can “slice” it into G-code, and Marlin firmware will do its best to print the final result.

Before Marlin can dream of printing, first you’ll need a 3D model. You can either download models or make your own with one of many free CAD programs, such as FreeCAD, OpenSCAD, Tinkercad, Autodesk Fusion 360, SketchUp, etc.

A high degree of knowledge is needed to model complex objects like a T-Rex Skull, but other objects can be quite simple to model. To get ideas and test things out, explore sites like Thingiverse, YouMagine and Printables and print things for fun.

Slicing

Slicers prepare a solid 3D model by dividing it up into thin slices (layers). In the process it generates the G-code that tells the printer in minute detail how to reproduce the model. There are many slicers to choose from, including:

Cura.
Slic3r.
PrůšaSlicer (formerly Slic3r Průša Edition) The new Kid on the block based on Slic3r.
Simplify3D is a commercial offering.

Printing

Marlin can be controlled entirely from a host or in standalone mode from an SD Card. Even without an LCD controller, a standalone SD print can still be initiated from a host, so your computer can be untethered from the printer.

Host software is available for several platforms, including desktop systems, Raspberry Pi, and Android tablets. Any device with a USB port and serial terminal can technically act as a host, but you’ll have a better printing experience using host software specifically designed for 3D printers. Current selections include:

Pronterface is an open source host by Kliment.
Repetier Host is a closed-source host by Repetier Software.
OctoPrint is an open source host for Raspberry Pi by Gina Häußge.
Cura is an open source host by Ultimaker. (WARNING: You can no longer manual select com port and speed, your printer needs to be auto detected by Cura)
Simplify3D includes both a host and slicer.

Many 3D printers ship with a customized version of Repetier or Cura. While this helps to associate the printer brand with a companion piece of software, these versions are usually obsolete and receive few upgrades. We recommend you download the latest generic version of your preferred host software instead.

3D Printer Firmware - Klipper Vs. Marlin Firmware

3D printers are a mere assembly of various stepper motors, controllers, and structural components. It is the 3D printer's firmware that ties everything together and brings your digital gcode file into the physical world.

Marlin was the first 3D printer firmware developed way back in 2011 for FDM 3D printers. Erik Van Der Zalm designed it for Ultimaker 3D printers which used 8-bit microcontrollers. Since 2011, Marlin has come a long way, and several 3D printers worldwide use some variant of the Marlin for their functioning.

But, in 2016, Kevin O'Connor released the Klipper firmware as an alternative to Marlin. Klipper promises high-speed 3D printing, better print quality, and several other features superior to Marlin. And it has grown tremendously since the first release and is quickly becoming the go-to firmware choice for many 3D printing hobbyists and manufacturers alike.

In this article, we'll compare Marlin and Klipper's firmware based on various criteria and understand the differences between these two. It should help you make an informed decision and choose the one that best matches your needs.

Let's get started.

3D Printer Firmware Explanation/Courtesy: Marlin

A 3D printer firmware is a bridge between your machine's software and hardware. It takes in the Gcode as the input and translates it into the physical actions of your 3D printer. It lets you access the minute features of your 3D printer and is partially responsible for the final quality of your 3D printed models.

The Marlin Firmware runs solely on your 3D printer's microcontroller, and it's designed to run on low-powered, 8-bit boards with limited processing power. With Marlin, the microcontroller computes the 3D printer's movements and is responsible for interfacing with the various hardware components.

This working of Marlin is taxing on the microcontroller, and with the limited memory of an 8-bit motherboard, there's little room left for any additional features. However, the recently released Marlin 2.0 works with 32-bit motherboards, giving you access to more processing power resulting in faster and better 3D printing performance.

In contrast, Klipper utilizes an additional processing unit (typically a Raspberry Pi) and the printer's microcontroller to deliver optimum printing performance. The Raspberry Pi has better processing capabilities and computes the 3D printer's movements according to the Gcode. It forwards these commands to the microcontroller, which is solely responsible for interfacing and transmitting the commands to the printer's hardware.

This configuration of two processors enables the Klipper firmware to implement higher-level features, which are impossible with low-end 8-bit microcontrollers. Advanced processing algorithms, higher stepping rates, the ability to add multiple machine controllers, and many other features are all possible due to the additional computing power of an external processing unit.

Firmwares are technically installed on the motherboard's chip, and you require an external computer to configure and flash the software on the printer's microcontroller. Marlin and Klipper are relatively easy to install but have slightly different installation methods.

Marlin is available to download for free, and customized configurations are available for various 3D printers. You can download the Marlin firmware from its website and install it using an SD card or directly from your computer. It's relatively easier to install than Klipper, and you can find several installation guides for various printers.

Klipper, too, is available as an open-source and free-to-download firmware. But, it has a slightly different installation process and might not be friendly for novice 3D printer users. It's a two-step process involving the installation of the Klipper firmware itself and a dedicated Klipper web interface such as Mainsail OS or Fluidd.

Yet, the process is easy to understand with a bit of help, and you can refer to our guides for installing Klipper with Mainsail OS and Fluidd. You can install Klipper directly on Octoprintvia the OctoKlipper plugin, but the two don't go together well. You'd be better off installing Klipper with the two mentioned web interfaces.

Firmware configuration is a crucial step in which you set the 3D printer's parameters within the firmware code. This step informs the firmware about the physical aspects of the 3D printer, thus customizing the software as per the printer's specifications.

Marlin has slightly involved configuration settings that might be daunting for a first-time 3D printer user. The printer's configurations are stored in two separate folders, and are different for each 3D printer. Editing these files is not a straightforward task, but luckily, plenty of guides are available online.

Marlin being a popular 3D printer firmware, you can easily find the configuration file for your particular printer. But, you'll need to reflash the entire firmware after changing the printer's configuration. This process is time-consuming and requires a code editor installed on your computer.

Klipper's configuration is relatively straightforward, and you can easily access it directly from its interface. Several configuration files are available on Klipper's website, which you can directly copy-paste and start 3D printing with Klipper. You can edit the configuration files now in its interface, and there's no need to reflash or erase anything.

Firmware add-ons help you to extract the most out of your machine and give you access to features that might be missing from the current version of your firmware.

For example, Octoprint is a popular add-on for Marlin firmware that helps you to monitor and control your 3D printer remotely. Octoprint is another open-source and free-to-use 3D printing host software with tons of other functionality. It's famous for its integration with several plugins, enabling you to execute various tasks.

You can customize your 3D printer's UI, attach an external monitoring display, access notifications on your Telegram app, and get a 3D map of your bed's level. Octoprint unlocks an entirely separate world of 3D printing, which might not be possible by merely using your machine with the Marlin firmware.

That said, Klipper, too, has its advantages in terms of functionality and ease of use. Mainsail OS and Fluidd are two of the most popular web interfaces which enable you to extract the most out of Klipper.

These two interfaces are solely developed for running Klipper firmware and make it easy for users to access Klipper's various functionalities. As both are web-UIs, you can easily control your 3D printer from any device. These also make editing configuration files a breeze which comes in handy if you're constantly changing your 3D printer's hardware.

Marlin and Klipper use different hardware configurations and significantly differ in their features. Klipper utilizes the additional processing power of the Raspberry and gets an edge over the Marlin firmware. Let's look at some of the significant differences in features of both the firmware.

Marlin

Linear Advance

Marlin's linear advance approximates the filament pressure in the nozzle and adjusts the flow rate accordingly. It helps to reduce the oozing of the filament during travel moves, thereby reducing the stringing in the 3D print.

Model Predictive Temperature Control

This temperature control system relies on a model simulation to bring the printer's hot end and the print bed to the set temperatures. As opposed to the traditional PID control, this technique is quick, reliable, and precise and controls the actual hot end temperature instead of the sensor. It helps you to achieve faster heating times with high accuracy.

Klipper

Smooth Pressure Advance

This feature is a replica of the Marlin's Linear advance. Klipper's smooth pressure advance gives you the same functionality and helps to reduce filament stringing. But, it's much easier to calibrate and adjust the value pressure advance value in Klipper than in Marlin. You can set this value in real time without needing to reflash the firmware or edit any gcode files.

Precision Stepper Motor movement

Klipper computes all stepper motor movements on a separate processor such as a Raspberry Pi. It then transmits all of these commands to the printer's microcontroller, whose sole job is to execute these lines of commands. This delegation of tasks leads to precise stepper movements as the microcontroller doesn't need to calculate and control everything.

High Stepping rates

Klipper can deliver high stepping rates of 175K steps per second with even 8-bit microcontrollers. Technically, you might never need such an extreme stepping rate, but if you decide to add more stepper motors to your 3D printer, Klipper's got you covered. It also results in precise motor movements translating to higher quality 3D prints.

Multiple Controller support

Klipper supports multiple controllers on a single 3D printer. This feature allows you to add a separate controller for extruders, print beds, leveling devices, and many more. It's easy to set up and gives you more control over all aspects of your 3D printer.

Input Shaping

Input shaping is unique to Klipper, which aims to reduce the ringing/ghosting effects in your 3D prints. Ringing occurs due to the vibrations produced when printing at high speeds. It approximates the vibrations of the printer's movements and computes the pathways that will cancel out these vibrations. Klipper aims to balance the print quality at high speeds with this feature.

Marlin and Klipper are exceptional 3D printer firmware that excel at what they do. Choosing between the two comes down to your workflow and expectation from your 3D printing machine.

Marlin is excellent for its ease of setting up and minimal features. The latest Marlin 2.0 can run on 32-bit motherboards, giving you access to increased functionality of your 3D printer. And you can combine it with Octoprint to remotely access your 3D printer and a slew of other handy features.

Klipper, on the other hand, is on the rise and is quickly gaining interest in the 3D printing community. It delivers prints at high speeds and with better print quality. It's updated more frequently, and once you get familiar with its interface, it's a breeze to use. Klipper will be more suited for users who need to get the most out of the machines and a fast 3D printing experience.

Obico is the successor to the popular Spaghetti Detective application and builds upon the foundation of its predecessor. Obico is available on Marlin via Octoprint. You'll need to install the Obico plugin on your Octoprint instance, and you're good to go. It's also easy enough to set up on Klipper, and you can get started using Obico for Klipper with a few lines of easy code.

Let's take a quick look at some of the notable features of Obico.

Remote monitoring and Control

Obico lets you remotely monitor and control your 3D printer, and you're not restricted to being on the same network as your machine. You can access your printer over a mobile network from virtually anywhere in the world.

AI Detection

Obico uses machine learning to detect failed prints and instantly notifies you if anything goes wrong. You can remotely cancel your print or let Obico decide it for you. This feature gives you added peace of mind and saves your precious printing time and filament.

Print status Notifications

Obico can send status reports of your ongoing print job on your mail ID, telegram app, Slack, and text message. It removes the hassle of constantly checking your phone, and you can work on other tasks without worrying about your print's progress.

Multi-platform Support

Obico is available both on Android and iOS devices as a mobile application. You can also access it on your desktop via your browser without installing additional software. You're no longer limited to a single device and can access your printer's live feed, regardless of your platform.

If you have issues getting Obico installed for your 3D printer, check out the complete setup guide or join the Obico discord server to get help.

Let us know your experience of using the Klipper for Ender 3. If you find Obico useful, please give us a star on GitHub, or leave us a review on our mobile app in the iOS App Store or Google Play Store!

Set up the Marlin firmware and upload it to the 3D printer

Many 3D printers run the popular firmware Marlin . The firmware is pre-configured for Ultimaker Original. Let's analyze the basic settings for other 3D printers.

The firmware is located at this address. Downloading. We press the button Download ZIP . The archive Marlin-Development.zip is downloaded. Unpack it to the selected folder.

Now downloading Arduino IDE to patch and upload firmware to 3D printer . Link. We press on Windows Installer . Installer arduino-1.6.0-windows.exe is downloaded. We launch it and install the environment Arduino IDE .

Go to the firmware folder and run the file Marlin.ino .

Opens Arduino IDE with firmware. We need a tab Configuration.h .

At the beginning we see references to calibration 3D printer . Scroll further and read: ' This is a configuration file with basic settings. Select controller type, temperature sensor type, calibrate axis movements and configure limit switches.'

Let's start with controller selection (MOTHERBOARD). The list of controllers is in the tab boards.h . Click on the triangle in the upper right corner and select boards.h .

Now look at the installed electronics. Here are some board types:

Melzi

RAMPS 1. 4

I have RAMPS 1.4.

Replace in configuration.h 'MOTHERBOARD BOARD_ULTIMAKER' with 'MOTHERBOARD BOARD_RAMPS_13_EFB'.

#ifndef MOTHERBOARD

#define MOTHERBOARD BOARD_RAMPS_13_EFB

#endif

Next select temperature sensor - thermistor . We see a large list of '//// Temperature sensor settings:'. I have an E3D-v5 hotend and a Chinese thermistor on the table. For E3D-v5 I choose '// 5 is 100K thermistor - ATC Semitec 104GT-2', for the table '// 1 is 100k thermistor - best choice for EPCOS 100k'. If the type of thermistor is unknown, you can choose 1, and if you don’t like the temperature, you can choose any and test. I change.

100K thermistor - ATC Semitec 104GT-2

Ordinary Chinese thermistor 100K

Hotend maximum temperature limit '#define HEATER_0_MAXTEMP 275'.

Hotend minimum temperature limit '#define EXTRUDE_MINTEMP 170'.

If the limit switch is not connected to the standard and its state needs to be inverted , then this can be done in the firmware without soldering the wires. Values false or true . The command M119 (for example in Pronterface ) shows the state of the limit switches. My limit switches are only in position HOME on MAX .

In position HOME

In position different from HOME on all axes

I did not need to change anything.

const bool X_MIN_ENDSTOP_INVERTING = true;

const bool Y_MIN_ENDSTOP_INVERTING = true;

const bool Z_MIN_ENDSTOP_INVERTING = true;

const bool X_MAX_ENDSTOP_INVERTING = true;

const bool Y_MAX_ENDSTOP_INVERTING = true;

const bool Z_MAX_ENDSTOP_INVERTING = true;

Change the direction of rotation of stepper motors , values false or true . Correct movements of the nozzle relative to the table :

- Along the X axis - to the left '-', to the right '+'.

- Y - forward '+', backward '-'.

- Z-axis - approach '-', removal '+'.

- Extruder. Extrude - thread extrusion, Reverse (retract) - rollback, thread retraction.

#define INVERT_X_DIR false

#define INVERT_Y_DIR false

#define INVERT_Z_DIR false

#define INVERT_E0_DIR true

Next comes setting limit switches 4.9000 We need to find out where they are located . How to find out? The origin is in the near left corner on the table surface , if the nozzle is brought to this point, then the limit switches MIN would work, if to the far upper right, MAX would work. I have three limit switches MAX at position HOME , so my settings are

// Sets direction of endstops when homing; 1=MAX, -1=MIN

#define X_HOME_DIR 1

#define Y_HOME_DIR 1

#define Z_HOME_DIR 1

Setting travel dimensions , after initialization at position HOME . Here we set the dimensions of the working area in X and Y, as well as the setting of the nozzle relative to the table.

If when the nozzle touches the table, the limit switch is triggered ( MIN ), as in Ultimaker Original, then the nozzle is adjusted relative to the table by moving the limit switch, and in '#define Z_MAX_POS' we write the coordinate value at the maximum distance of the nozzle from the table. The coordinate can be found by command M114 or by looking at the display screen.

If the Z limit switch is activated at the maximum distance of the nozzle from the table ( MAX ), then you need to find the Z dimension yourself. Set the value '#define Z_MAX_POS' to be initially higher than the norm, for example 250 with a dimension of 200 mm. We lower the nozzle until it touches the table and on the display (or by command M114 ) we see a coordinate greater than zero, now subtract the obtained coordinate from the set large value and get the Z dimension, which we will now write in '#define Z_MAX_POS'. Based on the results of printing the first layer, this value can be corrected. . The extruder is also an axis. My settings.

Now let's see how I got them . All axes are equipped with stepper motors 200 steps per revolution, 16 micro steps per step (set by jumpers on the board). Along the X and Y axes there is a GT2 drive belt with a 2 mm pitch and 20 teeth pulleys , in total we get the formula (200 * 16) / (2.0 * 20). Along the Z axis there are M8 studs with a thread pitch of 1.25 mm, the total formula is 200 * 16 / 1.25.

We find specifications (datasheet) for installed stepper motors . We see that in one step the shaft rotates 1.8 degrees, which means 360 / 1.8 = 200 steps per full turn. This parameter is the same for most stepper motors installed in home 3D printers.

Belt profiles commonly used on 3D printers and their step . Original here, page 61.

Pulley

How to measure screw pitch ? We measure the section of the screw and count the turns on it, then divide the length of the section in millimeters by the number of turns 20/16 = 1.25 mm. For a more accurate result, we measure the section of maximum length.

The setting of the extruder depends on the reduction ratio and the feed gear diameter. We will select experimentally , after the first firmware upload to 3D printer . Unscrew the nozzle and reduce the minimum nozzle temperature limit to 5 degrees '#define EXTRUDE_MINTEMP 5'. Now the extruder will work with a cold nozzle, which is what we need. We do not change the extruder settings yet. For configuration, I use the Pronterface program. To begin with, we set 50 mm and the speed is 100 mm / s. 50mm is the length of the bar that goes through the extruder. We measure the length of the rod passed through the extruder with a ruler or caliper.

Selecting the extruder setting, we achieve an exact figure on a reasonable length of the rod, for example 300 mm. After setting , we will return the minimum temperature limits '#define EXTRUDE_MINTEMP 170'.

The following digits are the maximum travel speed limit for the axes . On X and Y I put 200 mm, I don’t touch the rest.

#define DEFAULT_MAX_FEEDRATE {200, 200, 5, 25}

Axis acceleration setting . At high accelerations steps may be skipped . You can pick it up by driving in the Pronterface program along the axes at a given speed. Here are my settings:

#define DEFAULT_MAX_ACCELERATION {1000,1000,100,10000}

#define DEFAULT_ACCELERATION 1500

It remains to activate LCD with SD card . I found my display on RepRap.org and identified it as RepRapDiscount Smart Controller .

Uncomment (remove double slashes) the following lines:

#define ULTRA_LCD

#define SDSUPPORT

#define ULTIPANEL

#define REPRAP_DISCOUNT_SMART_CONTROLLER

There is another tweak to improve the accuracy of operation of some limit switches. When setting zero in Z, I encountered the fact that after each initialization of HOME , the position of the nozzle above the table changed slightly. Digging through the firmware, I found a parameter responsible for initializing the limit switches. Go to tab Configuration_adv.h and look for the line '#define Z_HOME_RETRACT_MM 2', change the value 2 to 5 and don't remember this parameter anymore.

It's time to upload the firmware to the controller. To do this, you need to correctly set the type of board and the number COM of the port in Arduino IDE . The card type and port number will be displayed at the bottom of the window. Don't forget to save changes (Ctrl+S) .

RAMPS

MELZI

0003 Arduino IDE you need to copy and replace all from the firmware folder 'Marlin-DevelopmentArduinoAddonsArduino_1.5.xhardwaremarlinavr' to the Arduino IDE folder 'C:Program Files (x86)Arduinohardwarearduinoavr'. After that, it becomes possible to select the board Sanguino (base board for Melzi ) and the desired type of processor . I don't have a Melzi board so I can't check.

For fill firmware click on the circle with an arrow.

The progress of uploading the firmware is displayed by the indicator

For this I use Pronterface . We enter the command ' M303 E0 C8 S260 '. Where M303 is the calibration command, E0 is the hot end, C8 is the number of heating-cooling cycles, S260 is the typical operating temperature of the nozzle.

Last results are written to firmware .

#define DEFAULT_Kp 12.22

#define DEFAULT_Ki 0.58

#define DEFAULT_Kd 64.08

Using the same scheme , we calibrate the PID of table . Command ' M303 E-1 C8 S110 '. Where E-1 is the table, S110 is the typical table heating temperature. The last results are written to firmware . My table heats up very slowly and therefore I have to restart the command due to a Timeout error.

#define DEFAULT_bedKp 105.94

#define DEFAULT_bedKi 4.97

#define DEFAULT_bedKd 564.11

The parameters set in the firmware can be found in the program Repetier-Host through the menu ConfigurationConfiguration EEPROM . You must first specify COM port in the settings and click the button ' Connect '.

When connecting a 3D printer to program Pronterface list of firmware parameters is displayed on the right side of the window

Also parameters can be seen on LCD display Via menu ControlMotion .

Would love to see similar instructions for Delta printers, CoreXY and H-Bot 3D printers.

Criticisms are highly welcome as the instructions will be posted on the 3D Wiki later on. The opinion of beginners is also very important, since all this is done just for you!

Install Marlin firmware on 3D printer using Arduino IDE

Hello everyone! In anticipation of the release of an updated version of the firmware for the Anycubic 4Max 3D printer, I decided that it was not very convenient to write another instruction on printer firmware, so I decided to separate this topic into several articles. As always, detailed and with pictures. Today I will describe to you how to install the Marlin firmware using the Arduino IDE. In subsequent articles, I will describe how to install the finished firmware through the Cura slicer, as well as how to self-assemble the firmware for subsequent installation using CURA.

The described technique is 100% suitable for 3D printers based on the Atmega 2560 microcontroller. The technique was tested on Anycubic 4Max and Anycubic i3 Mega 3D printers, as well as on Anycubic Mega-S.

I warn you, with other models there may be nuances.

And so, less words and more deeds, let's start.

It is assumed that you have the firmware sketch itself. Where you got it from is another story.

Let's also assume that your firmware is ready, all the changes have been made and you need to flash it.

For this we need the Arduino Ide development environment. You can download the environment here.

There are a lot of instructions for installing the Arduino IDE on the net, so there is no point in repeating it.

Downloaded? Installed? Now we continue.

The following libraries must be installed:

U8glib

TMC2208Stepper

0006 To do this, select the menu item " Sketch " -> " Connect library " -> " Manage libraries ".

In the search bar, enter U8glib

Select a library from the list of search results and click Install.

Repeat these steps to install the TMC2208Stepper library.

Now restart the Arduino IDE. Or just close the app and launch again.

Now everything is ready for the next step.

Using the Arduino IDE, open the file anycubic-4max.ino, or marlin.ino, or another file with the same extension. These details must be clarified with the author of the firmware. If we talk about pure marlin, then you need to open the marlin.ino file there.

If you need to correct or edit something, do what is necessary and save the results.

At this stage, it is mandatory to close all slicers, or even better, restart the computer.

Now is the time to turn on the 3D printer.

We connect the printer to your computer/laptop. Install drivers if necessary.

Set the parameters as shown in the screenshots:

Select the board:

Select the processor (motherboard microcontroller)

Select the port.