Posts Tagged ‘ reprap firmware

New 3D Printer: Tevo Little Monster + Duet Conversion

For some time I’ve been considering the purchase of a delta 3d printer.  After much research, I settled on a Tevo Little Monster (TLM below).  It was a bittersweet purchase, since I had to sell my first printer (after 5+ years of ownership), my Makerbot Replicator (original), to both make capital, and make some room for it.

Tevo Little Monster and the C-Bot: New best friends.

Tevo Little Monster and the C-Bot: New best friends.

This blog post is mainly written as a resource to myself to track info, troubleshoot problems, and list upgrades.

TLM Links:

TLM Pros:

  • Price:  I picked it up for $750 and free shipping.
  • Print Volume:  The machine is a beast: 45″ tall (without the spool holder, which makes it even higher), with a diameter of around 23″. It has a print volume of roughly:
    • 500mm tall (I was able to squeeze out 510mm)
    • 350mm diameter.
  • One of the main reasons I bought this printer was is ‘beautiful in simplicity’ construction: Despite the size listed above, the frame is only made up of 5 parts:  The 3 OpenBuilds C-Beam style extruded arms that connect to the top/bottom plates.  Everything was cut to the same length, and it was square immediately after bolting it together with no adjustments.
  • Integrated BLTouch in the delta effector.  Docs here.
  • 120v AC bed with SSR: ‘Nuff said.
  • Elegant electronics boxes and power cabling.
  • A ‘hanging bowden’ style extruder:  Keeps the mass directly off the delta effector, and decreases the bowden tube length significantly.  Based on experience, I dislike bowden’s and the blobs they produce.

TLM Cons:

  • MKS SBase V1.3 : While it runs Smoothieware and comes with a small touchscreen, I’ve heard quite a few problems from people running this knockoff Smoothieboard.  It also uses integrated DRV8825 steppers, which historically aren’t the best choice for 3D printers (needing separate ‘TL Smoothers’ to help remove artifacting).
  • Knock-off hotend and extruder:  While these are based on the E3D-v6 hotend and Titan extruder, they’re complete knockoffs.  And they gave me more grief than anything else stock on the bot:
    • The knockoff Titan extruder started squeaking in the first month.
    • The PTF fitting in the knockoff heatbreak disintegrated, dropping metal chunks into my filament path.  I didn’t realize this until taking the whole thing apart and shinging a light in there, and seeing stuff reflect back.
    • I didn’t realize it at the time, but it appears that the heatbreak isn’t all metal (like a standard E3D) : It had some sort of plastic liner.  Later, that liner failed, and completely jammed it.
    • I’m not sure the ‘.4mm nozzle’ was really .4mm at all.  After swapping to a legit .4mm volcano nozzle, I noticed an improvemnt in print quality.
    • Basically, ditch that entire hotend for the real thing and save yourself a bunch of pain.
  • The bed isn’t removable. However, you have plenty of access to it, so I don’t feel removing prints from it should be an issue.  And since it’s mounted directly to the base of the machine, I don’t see any calibration issues if I have to really pull on the print to get it off.


First thing, the knock-0ff Smoothieboard had to go.  My C-Bot has been running RepRap Firmware on a RADDS setup for some time, so for this bot, it was time to get the real deal:  A Duet Ethernet with touchscreen.



  • Remaining parts of a real E3D-v6 Volcano Hotend (hotblock, heater cartridge, and thermistor)

Duet Pros

I can’t say enough good things about the Duet ecosystem.

  • 32 bit processor, no delta computation speed issues.
  • Live tuning of nearly every value:  Via the Duet Web Interface (or any connected gcode sender) you can live tune nearly ever firmware setting.
  • Updating firmware is as easy as uploading a single file.  No pre-compile (or Arduino IDE) necessary.
  • Integrated steppers + 1/256 silence : The integrated TMC2660 drivers, when driven at 1/16 microstepping uses their ‘microPlyer’ tech to interpolate to 1/256 : The loudest thing on the machine is the PSU’s fan.  Creepy quiet.  you can check out their pdf datasheet here for more techy-info, or this forum post.
  • RepRap Firmware : Having used Marlin, Repetier, and Sailfish firmwares in the past, RRF is hands down my favorite.  Super easy to edit, and create custom macros.
  • Duet Web Control (DWC) : Comes with its own web-server, similar to Octoprint, but specifically for the Duet hardware.
  • Actively developed, active community/forum.

Duet Links

RepRap Firmware Links

Assembly Notes

The assembly of the TLM took a little under three hours with the help of a friend, following the printer instructions that came with it.  Nothing was missing, nothing went wrong.  The only think that took a chunk of time was rewiring the electronics to plug into the Duet.

  • For setting up the TLM with the Duet, this is the assembly guide I used: : This was a lifesaver!  Used all their firmware configurations by default.  There’s also a forum post here that discusses this conversion.
  • Had to rewire the endstops:  The order of the wires that plug into the Duet are a very different order from the wires that plugged into the MKS SBase, and are an even different order than how they plug into the endstops themselves.  Tracking this order is (obviously) really importing when rewiring them!
  • All the other connectors that plugged into the MKS SBase plugged directly into the Duet, except I had to cut off the side-clips so they could slide into the Dupont conectors correctly.  A combo of side-cutters and exacto-knive
  • BLTouch :
    • Had two sets of wires:  One needed entirely rewired to plug into the Duet expansion pin, while the other needed trimmed & rewired to a single plug, since the other wires weren’t needed.
    • Had to cut the trace on the board (after removing from the delta effector) to switch it from 12 to 24v.
  • I needed to switch the PSU from 220v to 110v, based on where I live.
  • As it turns out, the thermistor for the heated bed was bad: I kept getting 9000 deg reading from the firmware.  However, and somewhat coincidentally, they shipped with an extra thermistor;  I taped it to the bottom of the silicon heater, and it was up and running.
  • The top of each of the tower carriages has a small set-screw that is what trips the optical endstops.  I hadn’t done any adjustments to these:  They ‘looked’ ok.  A few weeks of printing later I checked them with my calipers, and they were up to 1.5mm off from each other, and felt loose in their threads:  I removed them all, applied blue threadlocker, and  screwed them in so a consistent amount was sticking out the top (6mm seemed like a good number).

Slicer Configuration

I use Simplify3D as my primary slicer :  It actually has a built-in preset for the TLM : Help -> Configuration Assistant -> Select Printer -> Tevo Little Monster.

I only had to modify a few things to start:

  • In RRF’s config.g, you need to set ‘M555 P2’ : This ‘sets compatibility’ to look like Marlin, which appears only to matter when trying to communicate with host software like Simplify3D, Octoprint, etc.  Up until then I had it set to P0 (RepRap Firmware), and I couldn’t get S3D to connect.  What’s interesting is that the baud rate seems to not matter:  I’ve had a number of different values and it connects fine.  RADDS, on the other hand, needs 115200.
  • Created a new ‘Tools -> Firmware Configuration’ setup for all the appropriate RepRap Firmware G & M codes.  It’s also important in the ‘Communication’ tab to set ‘Flow Control’ to ‘Hardware Flow Control’.
  • The above Duet assembly guide Thingiverse link comes with all the needed configuration .g files to get things working properly.  To support them, here’s my start/end scripts.  Obviously, you need to ‘Run Mesh Grid Compensation’ (G32) to store out the heightmap.csv that the G29 reads before print.  But you really only need to do this once in a great while.
; starting script
G32 ; Run the bed.g macro which homes and auto-calibrates the machine - also loads the last mesh grid
G92 E0 ; zero extruder
M98 PpurgeBeforePrint.g ; Purge the extruder along the front of the printer
; ending script
G1 E-10 F900 ; Retract 10mm at 15 mm/sec of filament to clean the nozzle.
M106 P1 S0 ; turn off filament cooler fan
M104 S0 ; turn off extruder
M140 S0 ; turn off bed
G28 ; Home all
M98 PplaySong.g ; play song when print ends
  • The purgeBeforePrint.g has the below code.  I found that printing small items, even with multiple skirts, didn’t always purge enough based on all the ‘pre-drool’ that came out of the head.  This lays down a fat line across the front.  A lot like my old Makerbot used to do.
G1 X-60 Y-150 Z.4 F3600
G1 X60 Y-150 Z.4 F1200 E30
  • In the G-Code tab, make sure to:
    • Set “Relative Extrusion Distances”.
    • Set the “Firmware Configuration Type” to the custom firmware I made above.
  • In the Temperatures tab, I always uncheck “Wait for  temperature controller to stabilize before beginning build”, since RRF will become non-responsive until that temp is hit.  I manage my own temps manually.

Building the C-Bot 3d Printer : Part 38 : PID Autotune on RepRap Firmware, fix z-artifacts

Jump to C-Bot blog index to see all the posts.

In my last post on the subject, I described how I completely rebuilt my C-Bot printer.  The main goal was to get better print quality based on some odd z-artifacting I’d been experiencing for some time.  But, the z-artifacing still persisted.

This post is to talk about both the solution to the artifact issue, and how to PID Autotune your hotend and heated bed with RepRap Firmware.

Solving the Z-artifacting

After the rebuild, the z-artifact was still there.  Was so frustrating to have a machine that printed so well, yet on the Z-axis, I’d get this:

z-ringing <- Click on it to make bigger, and look on the inside of the print.

The real oddity was that the artifact didn’t match the pitch of my leadscrew, which seemed like the obvious culprit, and the period of the artifact could vary based on what you were printing.  For example, a 20mm calibration cube showed off the issue much more than the above cylinder.  And it was more of a square-wave, not an s-curve.

3D printer people to the rescue:  I posted my issues to the ‘3D Printer Tip, Tricks and Reviews‘ Google Group, and through a lot of back and forth discussion (thanks JetGuy + several others), the users figured it was either one of two things:

  • Thermal expansion of the bed during the bang/bang heat cycle was causing these anomalies.
  • The hit the heated bed was making on my power supply:  When I built my machine 2 years ago I was recommended a fancy PC power supply (Corsair CTX 500), but as it turns out, this may not have been the right choice for a 3D printer.

Check Thermal Expansion

To troubleshoot the thermal expansion, user Joseph Chiu suggested a great idea:  Shine a laser off a mirror on the bed during the heat cycle, and track the dot on the wall.  If the dot moves during the bang/bang cycle, then it’s thermal expansion.  So, I gave it a shot:  Heated up the bed, waited for the temp to start banging back and fort, and then stared a dot on the wall…

frikkin_lasers The ol’ Replicator1 served as a based for the vice holding the laser.

That laser was bright, so I moved the mirror so it hit a “splotch” on it, and gave a nice diffusion pattern on the wall.  This was much easier to look at, and track the specks to see if the changed / moved : The did not.  This is not a thermal expansion issue.

Check Power Supply

The easiest way to check if this is a power supply issue?  Just ‘not print with the heated bed on’:  I normally always do, at 60c:  Not required, but sometimes helps large PLA prints stick better over time.

So, I did the same cylinder print with no heated bed and: The z-artifacting was gone!  Can’t believe I’ve been having this issue for a year-ish, and never realized it was the amp-draw the heated bed puts on the PSU, even though the PSU is rated for it, based on numbers.

Compare PID Tuning vs no heatbed

One thing I’d never done since upgrading the bot to RepRap Firmware, was PID autotune the hotend, or bed:  The defaults seemed fine, and the temp curves as shown in my slicer seemed “good enough” : I could easily see the bed overshoot based on the bang/bang setup, and a slight wobble on the hotend.  But I figured this would be a good time to PID autotune both the hotend and bed (discussed in more detail in the next section):  Would this help any of the z-artifacting?

Why, in fact it does.  Here’s a comparison shot:


‘Bed off’ and ‘Bed with PID Autotune’ are nearly the same:  The artifacing caused by the bang/bang is completely removed, and only a very slight, larger-period artifact remains (which I’m happy enough with at this point).

I should also note that my temp curves, for both hotend and bed, are now dead flat.  PID tuning completely makes a difference.

However, I noticed that while the pid-tuned bed works, the LED strips on my bot flicker with the same frequency as the SSR controlling the bed:  The same power-hit that caused the bang/bang artifact is still there, it’s just happening at such a high rate, the artifact is being averaged out of existence.

For future improvement, I need to choose one of these:

  • Get a separate power supply for just the 12v bed.
  • Switch to an entirely separate 120v AC heated bed.  This is the option I’m currently investigating.
  • Switch all my electronics out to 24v (ugh).

But in the meantime, at least the stupid z-artifact is gone.

PID Autotune your hotend and heated bed in RepRap Firmware

These are the steps I went through to PID autotune my hotend and heated bed in RepRap Firmare:  None of it hard, just took a good amount of digging online to figure out what exactly needed to be done.

In RRF gcode, ‘H’ Is the heater number: H0 is the bed, H1 is the first hot end, H2 the second etc.

PID Autotune the hotend

To PID autotune the hotend, these were the steps I took:

  • Position nozzle over bed
  • Turn on cooling fan 50% to simulate real printing environment.
  • Start with a cold hotend.
  • Enter this gcode, + the result returned as it’s ran:
    • I chose 230c as the target temp, since I print a lot of filament at that temp.
    • If you get an temp overshoot error during the tune, you may need to add / adjust your M143 in config.g:  The default value for hotends is 262c.

M303 H1 S230
READ: Auto tuning heater 1 using target temperature 230.0C and PWM 1.00 – do not leave printer unattended
READ: Auto tune phase 2, heater off
READ: Auto tune phase 3, peak temperature was 234.6
READ: Auto tune heater 1 completed in 228 sec
READ: Use M307 H1 to see the result, or M500 to save the result in config-override.g

  • Then entered this gcode, the result returned as it’s ran:
M307 H1
READ: Heater 1 model: gain 325.3, time constant 117.3, dead time 5.0, max PWM 1.00, mode: PID
READ: Computed PID parameters for setpoint change: P12.9, I0.110, D45.0
READ: Computed PID parameters for load change: P12.9, I1.026, D45.0
  • Finally entered this gcode to save the results out to config-override.g
  • Which in turn, added this info (actually more, but this is what’s important to this operation) to config-override.g
M307 H1 A325.3 C117.3 D5.0 S1.00 B0 
  • Note, the B0 = PID tuned.  B1 = bang/bang.

PID Autotune the heated bed

To PID autotune the heated bed, these were the steps I took.  Note, it’s very similar to the hotend above.

  • Start with a cold heated bed.
  • Enter this gcode, + the result returned as it’s ran.
    • I chose 60c as the target temp, since I print a lot of filament at that temp.
    • If you get an temp overshoot error during the tune, you may need to add / adjust your M143 in config.g:  The default value for heated beds is 125c.
M303 H0 S60
READ: Auto tuning heater 0 using target temperature 60.0C and PWM 1.00 - do not leave printer unattended
READ: Auto tune phase 2, heater off
READ: Auto tune phase 3, peak temperature was 61.2
READ: Auto tune heater 0 completed in 1105 sec
READ: Use M307 H0 to see the result, or M500 to save the result in config-override.g
  • Note, it took forever for this to finish, since it wants the bed to cool down before it completes.  I had to point a fan at it to help it along after ‘phase 3’.
  • Then entered this gcode, the result returned as it’s ran:
M307 H0
READ: Heater 0 model: gain 111.6, time constant 814.0, dead time 20.5, max PWM 1.00, mode: PID
READ: Computed PID parameters for setpoint change: P63.5, I0.078, D911.1
READ: Computed PID parameters for load change: P63.5, I1.082, D911.1
  • Finally entered this gcode to save the results out to config-override.g
  • Which in turn, added this info (actually more, but this is what’s important to this operation) to config-override.g
M307 H0 A111.6 C814.0 D20.5 S1.00 B0
  • B0 = PID.  Previously, it was B1, bang/bang.

Configure config-override.g

The M500 command entered above does a live update to the config-override.g script living on the SD card, which is a great feature.  However, I’d never used this feature before, so my config.g had no idea to execute this script.

To do so, simply (I did mine a the bottom), enter this gcode in your config.g


This will then execute the contents of config-override.g from within your config.g, when the machine boots up.

Optionally, you could simply copy the M307 lines (as generated by M500) from config-override.g and paste them directly into config.g, and remove the M501 call.  Either will work.

PID Autotune related gcodes

  • M135 : Set PID sample interval
  • M301 : Set PID parameters
  • M303 : Run PID Tuning
  • M304 : Set PID Parameters – Bed  :  This command is identical to M301 except that the H parameter (heater number) defaults to zero.
  • M307 : Set or report heating process parameters

Jump to C-Bot blog index to see all the posts.

Building the C-Bot 3d Printer : Part 36 : Adding an inductive z-probe to RepRap Firmware / RADDS

Jump to C-Bot blog index to see all the posts.


This post describes how I installed an inductive Z-probe on my C-Bot 3d printer, using RADDS hardware with RepRap Fimrware.

My C-Bot printer has a 12″ square build plate, with 4-point screw leveling: Not the easiest thing to keep level.  I decided to tackle installing an inductive Z-probe to help with the leveling, since RepRap Firmware supports it.

Very important:  Before you get started, you’ll either need an aluminum build plate, or some copper tape you can stick on your existing surface at the points you want to probe.

Other info:

  • This sensor works in conjunction with your Z-endstop:  You still home using the endstop.  But after the home, the probe takes over fine-tuning the leveling process.

Get the probe:

I picked up a LJ12A3-4-Z/BY inductive probe off E-bay some time back.  It’s stats:

  • 4mm sensing distance (to iron)
  • NO, PNP
  • 6-36v input, 300ma
  • Brown = Positive, Blue = Negative, Black = signal

Make a bracket:

I modeled up a bracket for it in Autodesk Maya, that would hang off the rear of my hotend gantry.

After the probe was mounted to the bracket, I adjusted the probe so it was about 1mm from the build-plate, if the nozzle was touching the plate.  Basically, a different in 1mm from nozzle to probe-base.


You can download the bracket from Thingiverse here.

Wire it up:

Voltage Divider:

Update:  I’ve been told you can drive these sensor directly off 5v:  I’ve not tested this,but if you’re going to attempt it, it’s worth a shot.  Save you from having to deal with the voltage divider below, and it means you can wire + & – directly into the RADDS board itself.

The probe needs 6-36v, the signal input on the RADDS board only accepts 5v, and my PSU is 12v:  Need to make a voltage divider!  Generally speaking, you need two resistors, with the smaller one half the value of the larger one. Like 10k & 5k.  Of course none of my resistors worked this well, and even when I did find some that may ‘sort of match’, they value they split wasn’t 5v.

After MUCH combinations, I came up with this:  Big 2k (really 1970 on my meter).  Small was two in a series: 1k (really 970) and 670 (really 660) for a total of 1730:  1730 isn’t remotely half of 1970, not even close.  However when setup on my beadboard, it was splitting out to 5.6v, which was the closest I got all day.

Later I read that anything over 3v would trigger things fine, so I was probably making this way harder on myself than I should have.

Mockup on the breadboard, using my Macbook Air as the ‘inductive aluminum surface’ 😉


Final shrink-wrapped setup.  Resistors hidden beneath the wrap.


RADDS Board:

The signal line needs to run into the “Servo PWM3 pin” (aka Due digital 39, AKA E0_AXIS endstop[3]), which is located in a cluster of solder-points on the corner of the board:  I soldered in a header, so that I could plug my signal line into it.


Connect the wires:

Signal from probe (since having it’s voltage lowered above) -> ‘Servo PMW3’ 5v pin on RADDS board (image above).

Positive & Negative probe leads -> PSU 12v +- terminals.

Update the Firmware:

G32 is the command that triggers the probing on the board.  But the probing can be setup two different ways:

  • Use a bed.g macro filled with M30 commands (and others).
  • Use config.g filled with M557 commands, no bed.g.

I like the idea of having a separate macro file to configure my probing:  If bed.g exists, when you execute a G32, the bed.g is parsed.  If there is no bed.g, G32 instead looks for pre-configured M557’s, that live in config.g.

Initial setup

Below, I discuss how I setup config.g and bed.g


When you first add the code for the probing in config.g, it’s important that you set the ‘Z offset’ in G31 to 0: You’ll later calibrate it and edit it with the final setting.  Here’s my probing section:

M558 P4 X0 Y0 Z1 ; M558 must come before G31.
G31 X49 Y52 Z.4 P500

To break it down:

  • M558 – Set Z Probe Type
    • P4 : Set the sensor type.  When using an inductive sensor plugged in to the PMW3 pin, you need to set this to 4.
    • X0 Y0 Z1 : Use the sensor for the Z axis only.
  • G31 – Set Current Probe
    • X49 Y52 : This is the distance in mm that the sensor is away from the nozzle (used my calipers to roughly figure this out).  Since my sensor is behind and to the right of my nozzle, these are both positive values, since 0,0 is in the front left of the bed.  You can leave these zero, but I’ve read that having them set makes the calibration more accurate.  However, it makes setting up bed.g more complicated (more on that below).
    • Z.4 : This is the difference in height between the sensor and the nozzle.  Set this to zero the first time you set it up, it will be calibrated later.
    • P500 : The ‘trigger value’ : Really only important if using an IR probe, but I read for switches just set this to 500.


This is where you define the points to probe/sample.  I’m doing a 5-point probe, but you can use as few as 3.

The only really confusing part is if you’ve entered any probe offsets in config.g’s G31 (above):  They need to be accounted for below, since you’re telling the system where to send the probe.  If the probe has a 50x, 50y offset from the nozzle, and you tell the probe to go to 0,0, it’ll try to run the nozzle outside the bounds of your printer, and much stepper chattering / printer shaking will ensue until you kill the power.

To calculate the below values, this was my process:

  • Home the printer, G28.
  • In my software (Simply3D), manually jog the toolhead around to the 5 points I want to sample  When I get the probe to a sample spot, I note the current X,Y value (which is for the nozzle), and I add the offset values  to it.
  • Make sure the probe is always over the bed!  If you position the probe off-bed, when it goes to sample that point, it’ll drive the bed straight up into your nozzle :(

My bed.g:

; Probe the bed and do 5-factor auto calibration
; These are the same toolhead points, but with the sensor offsets added. Note, to use these points, you must set config.g's G31 X49 Y52
G30 P0 X49 Y52 Z-99999 ; Four... - Front Left
G30 P1 X49 Y305 Z-99999 ; ...probe points... - Back Left
G30 P2 X299 Y305 Z-99999 ; ...for bed... - Back Right
G30 P3 X299 Y52 Z-99999 ; ...levelling - Front Right
G30 P4 X149 Y152 Z-99999 S5 ; 5th probe point + store the levelling - Center
G1 X0 Y0 ; Send X & Y back to zero before print starts. This is commented out during the initial calibration.

To break it down:

  • M561 – Set Identity Transform : Clear out any previous probing transformation done.
  • G28 –  Home : Must always home before probing.
  • G30 – Single Z Probe :
    • P# : Each sample point must be assigned an index, from 0-4.
    • X# Y# : the location on the bed to send the probe.  These include the offset set in config.g’s G31.
    • Z -99999 : A value less than -9999 tells the system to probe here.
    • S5 : The final probe has the S value entered, telling it to store all 5 points.
  • G1 X0 Y0 : Send the toolhead back to X0 Y0 before print starts.  Just something I like to do, since I purge the nozzle there.  Note, during the initial calibration stage this is commented out, which makes setting the probe to nozzle z-height easier (more below).

Calibrate the nozzle-to-probe height

As discussed above, I set my proximity sensor to be about 1mm above my nozzle height.  These sensors have a 4mm detection distance for highly inductive materials like iron, but for aluminum, it’s much closer, around 1mm it seems.

Once the config.g and bed.g have been updated, fire up the printer, heat up the nozzle and bed (if you can) and execute a G32:  This will both home, and then start the probing sequence (based on what you’ve defined in bed.g).  Be excited as you watch your printer automatically drive around probing for points!  It’s important the nozzle/bed is heated up, because thermal expansion.

When the probing is done (and everything is still hot), use this process to determine the nozzle-to-probe height difference:

  • You can either enter the below commands, or use some other control software (Simplify3D) to do it.
  • G1 Z0 ;  Send the bed\nozzle to the current Z0 position.  This should move the plate close to the nozzle, but not touch it: Should be 1mm or less away.
  • G92 Z10 ; This tricks the machine so it thinks the toolhead is actually 10mm above the bed.
  • Slip a piece of paper between the nozzle and build plate.
  • G91 ; Set Relative moves.
  • G1 Z-.1 ; Start raising the bed\lowering the nozzle by -.1mm values.
  • Track how many moves you make.  Keep raising the bed\lowering the nozzle until the paper just barely moves:  You should still be able to slip the paper under the nozzle.
  • Write that number down.  Mine was -.4mm.
  • Let your machine cool, power it down.

Update config.g and bed.g

Take the positive value of that number from above, and update your config.g’s G31 Z# with it:  This is now your calibrated offset!

G31 X49 Y52 Z.4 P500

In your bed.g, enable the last line to send the toolhead back to G1 X0 Y0 if you want.

The next time you run a G32 and then send the nozzle to Z0, it should be just touching the build plate, allowing you to slip a piece of paper under it with the same friction as above.  If not, something is amiss.

However, it’s possible this position still isn’t optimal for printing the first layer:  I did a test print with a hollow cube (no roof, no floor, 2 shells) just slightly smaller than my build volume.  The nozzle was still slightly too high for good first layer adhesion.  Rather than constantly updating your firmware value to try and tweak this, you can use your slicer software, covered below.

Update your print Profiles:

My slicer software is Simply3D, but I’m guessing other slicers (Slic3r, Cura, etc) work similarly.

Start Script

The start script is the gcode that is execute before a print starts.  The only change I had to make was switch out the line that did the home operation (G28) with the new G3d command, which calls to bed.g, which homes and probes.  This is what mine looks like:

G92 Z0 E0 ; Set current z position to zero.
G1 Z2 ; Lower Z to be safe 2mm.
G32 ; bed.g - home and probe bed - If not probing, this would be G28 instead to just home.
G1 E50 F600 ; Purge nozzle 50mm 10mm sec When a print ends it's retracted by 30mm.
G92 E0 ; zero extruder
G1 X0 Y10 ; Move nozzle to left front corner of build platform.
G92 X0 Y0 ; Zero X & Y here to start the build.

Refine the Z-height

As mentioned above, my first layer was a bit too high, and wasn’t quite sticking right.  Simplify3D has a section in its ‘G-Code’ menu called ‘Global G-Code Offsets’: These allow you to provide an additional global offset to all values in the gcode.  As it turns out, setting XYZ to 0,0,-.025 mm made for a great first layer.  Iterating with this value is far easier/faster than updating the firmware.

Thoughts for dialing this in:

  • With the Z value set to zero (the default), do a test print of a box with a solid bottom.
  • If the first layer doesn’t stick well enough, cancel the print, lower by -.02 and try again.  If you see the extrusion curling up and off the bed as it extrudes, it’s actually to close, and add .02 and try again.
  • Keep iterating on this process until you get a nice stuck first layer.

Final Thoughts

Now that it’s working, I’m so sad I did’t do this sooner.  Full-volume first layers are just ‘spot on’ now.  It’s almost magical to watch it work.  Get an aluminum plate and do this mod!

Resource List:

Jump to C-Bot blog index to see all the posts.

Howto: Pause RepRap Fimrware for filament reload at a specific layer number

Like my previous two posts on the subject:

…since I’ve switched my C-Bot 3d Printer to RepRap Firmware, I needed to figure out how to pause it at a specific layer height in gcode.  The wrinkle this time is I have no LCD hooked up to it, so I wasn’t sure how to unpause it.

As it turns out, it’s darn simple (as it should be):  Enter a M226 at the line you want it to pause:

... bunch of gcode....
; layer 2, Z = 0.38

And bam:  It’ll stop right there, executing what’s in your pause.g macro.  From there, you can change filament as needed, then enter a M24 (executing the resume.g macro) via a connected serial console to start the print back up.

Optionally, like mentioned in the above posts, you can use your slicer software (if it supports it) to post-process the gcode to add in the M226 where you need.  Look to those posts as examples of how to do this.

Note:  I’ve had this fail via Octoprint:  3 hours into a 6 hour SD print the gcode triggered an M226 where it was supposed to.  I watched as the print paused, and then I heard all the fans kick off:  The whole board reset, thus canceling the print.  I tried simple tests with Octoprint using small calibration cubes and got similar (negative) results after only a few lines of printing.  Doing the same tests via Simplify3D’s serial console (still printing off the SD) worked however.  In fact, as a sanity check, during the pause I’d disconnect S3D entirely and unplug the USB, then reconnect USB and reconnect the serial console:  I was able to successfully issue a M24 to restart the print, so right now I’m going that route if I need to do a filament change.

Installing RepRap Firmware on RADDS

Jump to C-Bot blog index to see all the posts.

This post can also be prefixed “Building the C-Bot 3D printer part 34:” 


This post covers the steps I went through getting RepRap Firmware (RRF) installed on my C-Bot’s RADDS/Due combo.   My goal is to lay out all the steps & pitfalls I went though to get it working, in detail, since I could find no page online that already illustrated this.  Even though I’ve used several other firmwares in the past there were may concepts that were new to me (and probably not new to those more experienced in programming), that I’ll hopefully illuminate to others that were as much in the dark as I was.

It is mainly about RRF, and not the RADDS hardware itself:  That is covered in depth by my C-Bot’s ‘Upgrade to Repetier‘ post, no need to dupe all that here.

Note, written in hindsight:  Had the “Duet Wifi” (or Ethernet) been available at the time I’d done this hardware upgrade, I would have gone that route.  If you’re considering this firmware as an option, I’d highly encourage you to go that route.  The hardware is more expensive, but you’re no longer dealing with a firmware port.

For some context of my experience (and I’m not saying my experience is ‘high’, more of a squishy-medium), previous firmware/hardware combo’s I’ve used/installed/tweaked include:

  • Sailfish/Mightyboard on my Makerbot Replicator 1
  • Marlin/Rumba on my C-Bot
  • Repetier/RADDS on my C-Bot

Why do this?

I had two main goals for installing RRF on my C-Bot:

  1. See if these weird vertical lines that were showing up on my prints when I switched to Repetier/RADDS would go away (and also to check out it’s overall comparative performance differences):   I figured this had something to do with Repetier & CoreXY printers.  As it turns out, it does not:  The same lines still show up in RRF :S  You can see pics of that issue in this Repetier Forum Post.
  2. Does firmware designed for 32 bit hardware have a leg up on firmware (Repetier) ported to 32 bit hardware?  The jury is still out, but my initial impressions (now that I’ve been using it for a few weeks) are positive.

Resource Link collection by webpage

Notes on RRF & it’s history

Big Thanks

Goes out to Dan Newman for his patience & tireless forum replies helping to guide me through this, plus other forum posters David Croker\dc42 (who helped write the dc42 fork of RRF) and GroupB.

My build environment


  • All of this work was done on an ancient Macbook Air running OSX Yosemite 10.10.5.
  • RADDS 1.5
  • Arduino Due R3 (Note, that version of the Due has a ‘reset bug’, described below under ‘Issues’.  You want a Due R3-E to avoid this issue).


  • Mentioned below, I installed the older Arduino 1.5.8 to get access to Bossac.
  • I do my text editing in Sublime Text 2.

Build from source


Note #1:  I did not do this (build from source).  Nor do you actually need to, but since I did so much work not knowing this, I listed it below.

Note #2 : You mostly like will still want to clone the git repository, shown below.

Scons is required to build from source, and I had a nighmarish time getting it installed, and around that time in the fourm posts someone said “why not just install a prebuilt binary” using bossac?.  Which I didn’t know how to do either :)  The key piece of knowledge from that was:

SCONS : Builds the source into a .bin
BOSSAC : Upload compiled .bin to the Due

For what it’s worth, here’s my notes for ‘building from source’:

Get the git repository

You’ll want this anyway even if you’re not building from source, since it has the precompiled binaries, plus example macros required later.

On my Mac, I have my git root set to:


This is my original install location:

$ git clone

So it installs here:


But since authoring this, DC42 has taken over, so instead you’ll want:

$ git clone

Which includes the RADDS builds.


I could only get scons installed by doing a MacPort.  And again, you only need to do this if you want to build from source.

$ port install scons

And then spending an hour getting various packages updated.  It was a nightmare.

Get bossac & configure Arduino IDE


To get bossac (which you need to later flash the compiled .bin to the Due) for the Mac, you need an older cut of Arduino, 1.5.8:  I can’t seem to find bossac anywhere on my Mac based on the latest release.

This is where you can find bossac on a Mac (note how I changed the Arduino App name so as to not clash with the more current install I also have):



bossac.exe seems to come packaged with the latest Arduino IDE:


Also, dc42 provides a download for it here:

Configure the IDE

Since I’d already done it back when I installed Repetier, I’m not sure how important this next step is. But if you run into problems:  You may need to ‘install’ the Due board in the Arduino IDE:  The bare bones instal doesn’t know anything about the Due.  Check out my post here under ‘Configuring the Arduino Due with the Arduino IDE’ on how to do this.

I didn’t get any further, since at this point I realized I didn’t need to build from source at all…

Flash precompiled binary / manual firmware update


Update:  If you’re using 1.18.1 or newer (the docs say 1.13 or newer, but it didn’t work for me until 1.18.1), you can use the auto-update function instead of this method.  See that section at the bottom.

You need bossac to flash a precompiled bin to the Due.  If you haven’t already get bossac installed, see the previous section for that.

BOSSA is an acronym for Basic Open Source SAM-BA Application.  Not sure what the ‘C’ is for…

There is a Mac standalone app for this, but it’s known to not work with RADDS, so spare yourself the trouble.


I had a number of problems trying to flash the bin:

  • The Due has two programming ports, the ‘Native port’ (furthest from the barrel-jack) and the ‘Programming port’ (closest to the barrel jack).
  • You’re supposed to be able to flash the bin over the Programming port, only having to press the (easily accessable) reset button.  I could not get it to work.
  • The only other alternative is to use the Native port, but to do that, you have to first press the Due’s erase button, then reset.  Issue is, the erase button is completely hidden by the RADDS shield.  So I had to unwire everything from the board to get it out of the case, pry the RADDS shield off the Due, and do the erase\reset\native port combo. But, it worked.
  • It appears this “can’t use programming port” may stem from a firmware issue on the chip that drives the Due’s USB (discussed at the bottom under “issues”).  Basically, whenever you power on the Due, you must also press reset before you can connect to it.

You need to know what USB port the Due is on.  The easiest way I found this was:  Power it on.  Press reset to get around bug.  In either the Arduino IDE, or in Simplify3D (the slicer I use), see what’s listed to connect to.

You also need to know which binary to install.  There are multiple ones available in the /git/RepRapFirmware-RADDS/Release/ folder: I started with RepRapFirmware-1.09r-dc42-radds-b.bin, being told that was the most tested and stable at this point.  I quickly later upgraded to RepRapFirmware-1.13a-radds.bin, which has the advantage of allowing future firward upgrades to occur directly off the SD card.  See the notes here, and here.


Based on the above bossac install dir, this is what I used to flash the bin to the Due:

  • Connect USB to native port on the Due.
  • Press erase on the Due.  I waited 5 seconds (not sure how long to wait but that worked).  Note if the RADDS shield is on the board and the erase button is hard to access, you can use a popsicle stick cut in half to reach it, with the help of a flashlight and extra pair of hands.
  • Press reset on the Due.  Again waited 5 seconds (not sure how long to wait but that worked).
  • Ran the below command:  The shell showed me the progress, with a successfully completion.
$ /Applications/Development/ --port=tty.usbmodem2621 -e -w -v -U true -b /Users/<USERNAME>/git/RepRapFirmware-RADDS/Release/RepRapFirmware-1.13a-radds.bin

The short version (without paths) for readability is:

$ bossac --port=tty.usbmodem2621 -e -w -v -U true -b RepRapFirmware-1.13a-radds.bin

Note if you can get the programming port to work, you need to set ‘-U false’.

If performed successfully, you should see something like this:

Erase flash
Write 195708 bytes to flash
[==============================] 100% (765/765 pages)
Verify 195708 bytes of flash
[==============================] 100% (765/765 pages)
Verify successful
Set boot flash true

Test initial connection

Once you’re flashed the bin, how do you know the firmware is actually working before moving foward?  These steps will let you know it’ safe to continue.  You can do this even before the RADDS is plugged into the Due.

Reminder:  Connect the USB cable in in Native USB port (the one furthest from the barrel jack) of the Due, then to your computer (order doesn’t matter).

The Due ‘reset’ bug

Note, it appears that my Due has a bug with the chip that drives the USB firmware : Because of this, after I power it on, I must press the reset button (on the Due or RADDS) for the firmware to actually load.  I had this same issue using Repetier.  If you don’t press the reset button after it turns on, your computer may not be able to communicate over USB correctly, and you’ll spend hours searching the internet like me trying to figure out why.  This is discussed in more details in the “Issues” section at the bottom.

Three different methods I used to connect to the machine, immediately after flash.  I’ve listed the USB ports that I used below, yours will most likely be different.

Connect via Simplify3D

  • Press reset on the RADDS board.
  • Via S3d ‘Machine Control Panel’, connect at 115200 baud to USB port /dev/cu.usbmodem2621 (on my Mac) or COM5 (on my PC)
  • See the section below for actually configuring Simplify3D for printing with RRF.

Connect via Arduino

  • Press reset on the RADDS board.
  • Tools -> Board -> Arduino Due ( Native USB Port)
  • Port -> /dev/cu.usbmodem2621 (on my Mac) or COM5 (on my PC) : Arduino Due (Native USB Port)
  • Open the Serial Monitor.  Set baud to 115200.
  • Make sure that “Newline” is set in the field to the left of the baud rate:  Fresh installs can have ‘No line ending’ set, which doesn’t work well…
  • Note that if the text “( Native USB Port)” doesn’t show up in the lists, the board isn’t connected properly, or the Due wasn’t configured properly.

Connect via Octoprint

  • It should be noted that as of Feb 2017, it’s possible the latest version of Octoprint auto-detects RRF now.  However, if you have issue, these older notes may help:
  • Based on this forum post, need this plugin in Octoprint to make it compatible with RRF:
  • Just browse the Octoprint plugin manager to this file to install:
  • To connect, press reset on the RADDS board, choose the serial port ‘/dev/ttyACM0’ (for the RPi) and ‘Connect’.
  • If no serial port shows up after pressing reset on the RADDS, reload the Octoprint page.
  • See the section below for actually configuring Octoprint for printing with RRF.

To test the connection

Enter M115 into your serial console to report config status and know it’s actually working:  If the SD is in there with a /sys/config.g file (more info on that below), it should print something similar to what I have below, otherwise it’ll report ‘no config file’ (which still means things are working).

Send: M115
Recv: FIRMWARE_NAME: RepRapFirmware FIRMWARE_VERSION: 1.09r-dc42 ELECTRONICS: RADDS 1.5 DATE: 16/02/27

Then I plugged the RADDS back on top of the Due, and hooked up all the wires (more on hardware hookup below).

Macro Config

Update:  Since I’ve written this blog, a new “RRF Configuration Tool” is out in the wild:  Seems very similar to how Repetier does it (and that’s a good thing).  I’ve not yet used this configurator myself, but it may be a good starting point.

Macro files are the way you configure RRF.  They are .g text files that live in the /sys folder on the RADDS SD card, and allow RRF to reconfigure itself every time you turn it on:  No longer do you have to recompile the source to make an adjustment:  Just tweak the file on the card and reboot.

To get started, copy the content of /git/RepRapFirmware-RAADS/SD-Image/sys-CoreXY (presuming you’ure using a CoreXY machine like me) to your sd card root, and rename it to /sys

From there you can start editing the file:  Each time you plug it back into the RADDS board and reboot (and press reset after…) the config will be in play.

Good overview post on initial config:

Good overview of macros in general:

The Wiki lists defaults for many Mcodes here.  I’ve experienced these defaults to in fact be incorrect in some instances:  If you plan on using a default, be sure to enter that Mcode into a serial monitor to see what it returns, and is valid.

Primary macros I use are as follows:


config.g is the main macro that is executed when the machine is powered on.  It’s akin to Configuration.h in Marlin & Repetier.  Below are the main steps I went through getting it configured, and describing what the M & G codes do… mainly for my own sanity as I learn this.

Set CoreXY Mode

Per, presuming your bot is CoreXY:

M667 S1 ;              set CoreXY mode

Setting max feed rates

Via M203

The wiki lists default values for M203 to be the values I list below.  However, before I set that, when I’d enter a M203, they’d actually come out to 6000 (mm/min) for XYZ:  Substantially slower than what I put in:  This was clipping my speeds going much past 100mm/sec.  Values below freed things up.

My Values:

M203 X25000 Y25000 Z25000 E8000 ;

Defining nozzle and bed thermistor

Via M305

I’m using a E3d-V6 thermistor for my Volcano hotend.

They state:

Use the Beta value 4267K.​
It’s 100k Ohm

M305 P T B R L H X

  • P : Heater Number : Not to be confused with the ‘P’ (tool) value of M563. 0 = heated bed (RADDS bed), 1 = first extruder (RADDS H0). 2 = second extruder (RADDS H1), 3 = third extruder (RADDS H2).
  • T : Thermistor resistance at 25c
  • B : Beta Value
  • R : Series Resistor Value

When communicating with the RADDS, if you enter a M305 P0, it’ll print the current state.

My Values (just a generic 100k one for the bed), RADDS has a 4700 ohm inline resistor.

M305 P0 T100000 R4700       ; P0 = Heater 0 = The bed.  Not sure the 'beta' value for this.
M305 P1 T100000 R4700 B4267 ; P1 = Heater 1 = The extruder nozzle. Beta per the E3D docs.

Note, you’ll know these values are wrong if at room temp (25C / 77F) your control software (like Simplify 3D) doesn’t read 25(ish)c : I had originally set R1000, and it reported the resting temp to be 60c, very, very wrong.

Note I’m using the default PID settings for both nozzle and bed, and they seem to be working just fine.

Defining ‘Tools’

Via M563

This is where you setup your hotend(s).

M563 P D H

  • P : Specifies the ‘tool‘ number, 0 -> infinity.
    • D : The drive(s) used by the tool : 0, 2, 3 : D0 <-(zero) Is the first drive after the XYZ steppers, so presumably the extruder stepper.
    • H : The heater(s) used by the tool : 0, 1, 3 : 0 = Heated bed, 1 = first extruder heater.

My Values:

M563 P0 D0 H1 ; Tool (P) 0 : D0 = Extruder stepper 1. H1 = First extruder heater.

To select a tool in gcode, use T# to select it, T99 to deselect (needed?)

Defining axis direction and enable values

Via M569

M569 P S R X Y Z E

  • P : Specifics the ‘drive‘ number, not to be confused with the ‘P’ (tool) value of M563.  0=X, 1=Y, 2=Z, 3=E (right?).
  • S : Whether the drive should move forward. 1 = forward, 0 = backward.
  • R : Logic level.  0 is Default.  Set to 1 to reverse logic if you’re using RAPS128.

My Values:

M569 P0 S1 ;  X
M569 P1 S0 ;  Y - I needed to reverse this.
M569 P2 S1 ;  Z
M569 P3 S1 ;  E1

Set Endstop configuration

Via M574

M574 X Y Z S

  • X, Y, Z : The switch type for the axis : 0 = none, 1 = low (min) 2 = high (max).
  • S : Logic level : Defines whether the endstop input is ‘active high’ (S1, the default), or low (S0).

My Values:

M574 X1 Y1 Z1 S0

You can use M119 to report the status of your endstops.  Makes it convenient to test them while holding them on.   I had a super nasty bug where my X endstop wasn’t seated properly in the RADDS board, so it always reported off.

Defining steps per mm

via M92

For all steppers, X,Y,Z & E

My Values, copied from Repetier (with X&Y divided by 2, since Repetier doubles the XY steps for core-xy machines), since I’m using the same SD6128 drivers at 1/32 microstepping.

M92 X199.743 Y200.542 Z804.91
M92 E325


They were an amazing pain:  I have a hotend cooling fan, and a PLA cooling fan.  I also have a case cooling fan I never could get working via the below config, so I just hooked it up directly to my power-supply so it’s always on (Repetier was able to control it, so +1 for it).

This is what finally worked:

M106 P0 T60 H1 ; Hotend cooling fan: Enable to auto kick on at 60c (make it 'thermostatic'). 
M106 P1 H-1    ; Filament cooling fan: Must do H-1, or it'll turn on with P0 for some reason.
M106 P1 S0     ; Filament cooling fan: Must do, or it will go full blast on start :S


  • If I didn’t declare P1 (filament cooler) non-thermostatic (H-1) it would turn on with P0 (hotend cooler).
  • If I didn’t set P1 (filament cooler) to a speed of 0, it would go full blast on machine start.
  • Still haven’t figured out how to hijack pin H2 to double as a case cooling fan (see complaint above).

Stuff to comment out / delete

From the default config.g:

  • All M540, M552, M553, and M554 (network) commands, not supported by RADDS.
  • M906 (motor current) commands : Not supported by RADDS.

Setting up extruder and bed PID

I wasn’t aware of this info at the time of my initial build, but there’s a great overview here on how to configure the PID on both your extruder, and heated bed here:

Note that with RRF v1.15, there’s a PID autotune feature that can be used.  As of this authoring though, only 1.14 has been ported to RADDS :-(

I will also note that the default PID tuning for the hotend has been working fine, and my heated bed has been on a bang/bang relay (also the firmware default).

Related MCodes (RRF v1.09 and newer):

  • M301 : Set PID for hotend.
  • M304 : Set PID for bed

And if you have RRF 1.15 or newer:


This macro is called to during a ‘home all’  G28 operation

+ homex.g, homey.g, homez.g are just like it, but only on those individual axes.


Make sure you set the G1 commands when moving the head some amount past your build volume, so they’ll be sure to hit the end-switches no matter what.  For example, my X platform width is 305mm.  So when homing:

G1 X-330 F3000 S1

I set it to go -330, just to make sure it hits.


If you want to use an inductive probe to help level you bed, you do all that magic in bed.g (or optionally in config.g with M557 commands).  I hadn’t set that up at the time of this post, but I did later:  Find a robust post here on setting up an inductive Z-probe:

Macro M & G code usage

Macros can live in the /sys folder, or in the /macros directory with any extension.

While in a macro, you can call another macro. Macros are searched in /sys directory and it is recommended to always specify explicitly the path.

M98 calls to other macros.

When are Macros called to?

  • config.g : Machine starting up
  • Pausing & Resuming:
    • resume.g :  M24 (Start/Resume SD Print)
    • pause.g :
      • M25 – (Pause SD print)  – From control panel\lcd\serial connection, not saved gcode.
      • M226 – (Pause SD print) – From gcode directly.
    • cancel.g : If a M25 is executed pausing a print, then you execute a M0, this is called to.
    • stop.g : Docs say this is called while M0 is executed, (or?) when a paused print is cancelled.  NOTE:  Mine doesn’t seem to execute at all though via a M0, paused or not.  I have no idea how to trigger this.
  • Homing:
    • homeall.g : G28 (Move to origin: Home)
    • homex.g, homey.g, homez.g : Called to for individual axes on G28.
    • bed.g : G32 (Probe Z and calculate Z plane) – If using auto leveling.  See my post here.
  • Tool selection:
    • tpre0.g : Before tool1 is selected
    • tpost0.g : After tool1 is selected
    • tfree0.g : When tool1 is freed

Wiring the hardware

I cover how to hook up hardware to the RADDS in depth in ‘this post‘, scroll down to the ‘Connecting the hardware’ section.

Some notes from this doc, for the RADDS board:

  • The minimum endstop headers are used for the endstops: X min, Y min, and Z min.
  • Thermistor position T4 is used for the heated bed.  This is the thermistor header farthest from the board’s corner.
  • Thermistor position T0 is used for the first extruder, T1 for the second, etc.
  • Controlling fans:
    • Fan0 with ‘M106 S# P0′.  Where S is 0-255 .  P0 is default, and can be omitted.  This if the hotend cooler.
    • Fan1 with ‘M106 S# P1′ :  This is the PLA  cooler on the hotend.

Configuring to print with RRF

If printing over SD, RRF expects your .gcode files to live in a /gcodes folder on the SD.

Print off the SD via MCodes & a serial connection

You can print via a serial connection by directly issuing M-codes:

M20                ; list sd card contents to see what's there
M23 myPrint.gcode  ; select the gcode to print by name
M24                ; start the print

Configuring Simplify 3D

  • In the ‘Firmware Configuration‘s’ FFF tab:
    • To tell it to control the second fan (PLA cooling fan) not the first fan (hotend cooler).
      • Set Fan Power: M106 S$ P1
      • Set Fan Off : M106 S0 P1
    • RRF uses M116 to stabilize temps (I’m told M190 & M109 are deprecated).
      • Stabilize Extruder Temp: M116
      • Stabilize Bed Temperature : M116
      • Note, you loose all serial communication while these are in use:  Including temp readings, so you’re a bit blind during that time if you have this setup to do so in your ‘start script’.
  • In the ‘Firmware Configuration‘s’ Communication tab:
    • Make sure that “Allow Command Buffering” is checked, and set the “Serial Cache Size” to 127 bytes:  When I had the default (63) set, I was unable to print over USB, it would lock the machine about half way though my ‘start script’, right after a G28 (home) operation.
    • Note, to print consecutively over USB, I have to reset the printer, and reconnect after each print, or it will lock up like mentioned above.  This is different behavior than Marlin/Repetier.
  • In the ‘Firmware Configuration’sMacros tab:
    • S3D’s default “Extrude/Retract” buttons in the Machine Control Panel don’t seem to behave correctly:  They want to extrude based on “absolute values”, not “relative” ones. The side effect is during a paused print, if you extrude 10mm, you can’t extrude any more unless you retract 10mm first.  To get around this, if you execute a M83 first, it’ll put the extruder in relative moves, and you can extrude as much as you want.
    • I make a Macro called “Relative Extruder Moves” and put a M83 in there.  I press that before I do any type of control panel extrusion.
  • Note you have to “Export” your firmware settings to get it to save.  The ‘save’ button doesn’t actually seem to save anything.
  • In a given Process:
    • Temperature Tab:
      • For all extruder and bed temp controllers, uncheck “Wait for temperature controller to stabilize before beginning build”.
        • You ask “Why?  This is a great feature”.  Indeed it is, and I agree.
        • However, while the temp stabilizes via M116, you’ll get no serial communication back from the board, making you both blind to what’s happening, and unable to communicate with it in any way, to (for example) stop it if needed.
        • You’ll need to pre-heat the machine and get it to temp before starting your print if you go this route.

Configuring Octoprint

  • Update 2: As of Feb 2017, it’s possible that Octoprint will auto-detect RRF, and the below plugins aren’t needed. I’ve note tested this myself though.
  • Update 1:  As of Octoprint v1.2.15, RepRapFirmware is now supported!  You still need to install the RepRapPro plugin, and update the “Settings->Features” section to “Select SD Files by relative path” & “Always assume SD card is present”, but otherwise it works!

Old notes below, before RRF was fully supported by Octoprint:

  • As of this authoring, the main branch of OP isn’t designed to work well with the RADDS SD card:  Doesn’t recognize it properly, so you can’t print off of it.  You can print off the Octop’s SD via USB however.  I’m not a fan of printing over USB, so I didn’t like this option.
  • Thanks to work by Mark Walker while I dealing with all this, he updated a dev branch of OP to recognize the SD card, making it possible to print from it like any other firmware.  To get this dev branch, follow the directions below.  It worked for me without a hitch.  Thanks Mark!
  • In the Octoprint’s settings, under ‘features’:
    • Check ‘Enable SD Support’
    • Check ‘Always assume SD card is present’,
      • …or you won’t be able to see the SD card on the RADDS.
    • Once you’re on the dev branch (below), also check ‘Select SD files by relative path’ to be able to print off the SD correclty.
  • Also don’t forget to install this OP plugin:
  • Finally, once you’ve switched to the dev branch, do not update Octoprint: It will overwrite the update, and you’re back to square one.  Hopefully they’ll roll these updates into mainline at some point.

Switch Octopi to the dev branch (again, no longer needed post 1.2.15) that supports printing off the SD card on RRF \ RADDS:

This is a condensed / modified version of this Octoprint FAQ.  Like they explain, only use sudo on the FIRST COMMAND listed below, and nowhere else.

SSH into your pi.  Then:

sudo chown -R pi.pi ~/oprint ~/OctoPrint
cd ~/OctoPrint
git pull && git checkout dev/rrpFileOpened
~/oprint/bin/python clean
~/oprint/bin/python install
sudo service octoprint restart

When Octoprint restarts, you should see this version at the bottom of the web interface:

1.3.0.dev784+gf8c67fd (dev/rrpFileOpened branch)

Updating the firmware

(According to the RRF docs) If you’re running v1.13 or newer, you no longer have to do the ‘press the Due reset button’ dance.  Instead, you can follow the process Dan Newman outline here, or follow the steps below (copied & modified from that page):

  1. Power down the RADDS board and remove the SD card.
  2. Download the latest RADDS compiled .bin file from:
    2. Rename this file to “RepRapFirmware-RADDS.bin”, and copy it to the “/sys” folder on the DS card.
      1. As an aside, if you were doing this for a normal Duet, the name would be “RepRapFirmware.bin”
  3. Also, download and place the below file in the SD card’s sys/ folder.
    2. If there already was an iap.bin in there, remove it.
  4. Eject the SD card and place it back into the RADDS.
  5. Connect to the RADDS over USB (or from a Panel Due) and send the command M997 S0.
    1. Important:  I was unable to get this to work using Simplify3D’s serial monitor, since S3D constantly pings the board for the temp. This caused the update to fail.  I was able to successfully get this to work via the Ardiuno IDE’s Serial Monitor.
  6. Wait about a minute and then reconnect to the RADDS board. The new firmware should be installed. The RepRapFirmware.bin file is removed from the SD card automatically.
  7. You’ll probably have to reconnect to the board via the Arduino serial monitor, but if you execute a M115, the new version info should be displayed.
  8. Note: When you do this with a RADDS board connected to peripherals (e.g., stepper motors), it is recommended to do this with the bot’s power on. Particularly if you have RAPS128 drivers which may, owing to their inverted enable, turn on during the upgrade and when the processor is running under the iapradds.bin firmware. Peripherals may draw more power than a computer’s USB port will provide (typically a max of 500mA).


Up until versions 1.18.1, I was unable to get this process to work.  It “just wouldn’t”, and I’ve have to manually update the firmware by pressing the on-board reset button via a broken-in-half Popsicle stick.  But when upgrading from 1.18.1 to 1.19.2, it magically started working.  So much easier now!



  • None


  • Can’t update Firmware via “M997 S0” : See notes directly above.
    • Solved:  Up until 1.18.1, this didn’t work.  But, when I upgraded from 1.18.1 to 1.19.2, it started working.  Finally!
  • M190 (Heat bed and wait for target temp) & M109 (heat hotend and wait for target temp) cause machine to loose communication during heatup.
    • The commands tell the machine to ‘do nothing until target temp is reached’.  This includes any serial communication in RRF (compared to Marlin\Sailfish\Repetier that keep the serial communication lines open in my experience).  The side effect is the appearance that you’ve lost USB connection:  Communication will come back when target temp is reached, but in the meantime you’re blind.  I don’t like it.
    • I’m told that M190 & M109 are deprecated in RRF, and to use M116 instead:  While this command works, it still also hangs all communication in the process as well.
    • Solved:  Don’t use any of those Mcodes, and just heat everything up before hand manually. I don’t like this, but it works.
  • Endstops not being detected no matter what combo of values is entered into M574.
    • Solved : X-endstop wasn’t seating correctly in the RADDS.
  • PLA Cooler fan turns on automatically when using M563 to define the first tool.
    • Solved : Setting Fan0 to thermostatic (turn on when hotend reaches certain temp) it aut0-fixed this.  Weird.
  • PLA Cooler fan doesn’t respect PWM control:  It’s either 100% on, or off.
    • Solved:  Needed tricky config.g, see above.
  • Extruder doesn’t seem to be reading the correct temperature.
    • Solved:  Wrong inline-resistor value: had 1000, should be 4700 (what’s on the RADDS boar).
  • RADDS case cooling fan is hooked to H2 (hotend heater2) in Repetier successfully : How to configure that as a fan in RRF?  Still haven’t figured it out yet.
    • In the meantime I rewired them to mains so they kick on automatically when the machine is powered on.
  • The Due reset bug: Whenever I power on the Due\RADDS, I have to press reset to actually make it boot the firmware.  This happens in Repetier too.
  • RADDS LCD is not supported at this time, but the PanelDue is.  Plus, it’s a touchscreen.

Jump to C-Bot blog index to see all the posts.