Leveling the Creality K1 bed

I posted previously that I purchased a new Creality K1.

I was a bit disappointed in how far off the bed of my K1 was from flat, when I got it. I had many print failures because the material would release from one side of the bed or the other. There are several calibration and bed cleaning activities that could be performed, but one of the most foundational is bed leveling, since almost everything builds from there.

The K1 has an automatic bed leveler, but there is only so much you can expect for it to be able to compensate for.

Fortunately, Creality provided a YouTube video showing the process in detail:

For those who like a step-by-step approach (with illustrations) I provide this process description:

1. Unplug the printer
2. Lay printer on its side with the door open (that way the door doesn’t open accidentally and break).

3. Take off the base of the K1 by removing the rubber feet and then the four plastic feet

4. Remove the back panel by removing the top and the left and right screws

You should now have a good view of the inside of the K1.

5. Plug the machine back in and turn it on. Do the self-check to get the current z bed map. Be careful now that you have a plugged in device.

6. Open the web interface (or the PC interface if using CrealityPrint) to access the bed mesh. To access the web interface, go to a browser and go to the machines IP address/#/home. On my PC, I had to adjust my Windows firewall for the screen to refresh, but on my phone and tablet I did not.

Refresh the screen on the web interface to make sure you get the most up to date information. As you can see there is quite a difference between the right side and the left side of the bed. I will adjust the right side and move the bed so it is higher on that side.

7. Move the z axis to lowest level using the web interface to the machine. Then unplug the machine.

8. Loosen the two screws that hold the tension in place

9. Squeeze the tensioner and remove the belt. You might need to jiggle it around a bit to get it to compress effectively.

10. Turn the screw that needs adjustment to change the bed level.

11. Squeeze the tensioner and replace the belt.

12.Tighten the screws on the tensioner.

13. Plug in the printer and turn it on.

14. Go back to step 5 and determine if you need to level the bed again – it is an iterative process. If so continue. It took me several times to get it right.

That is about as good as I could hope for.

Purchased another new 3D printer – Creality K1

I have had numerous 3D printers over the last couple decades. There was the:

• PrintrBot — mostly made out of laser cut wood
• PrintrBot Simple Metal
• Creality Ender-3
• Creality Ender-3 S1

I was helping to setup a new Creality K1-Max at the woodshop and liked many of its features so I thought I’d get its smaller brother the Creality K1 for my home.

The K1 series of printers have many automation features that take away some of the tedium of 3D printing (like Z axis calibration…). It will also remove the need for my Raspberry Pi I had in the garage running Repetier to drive the printer. It also has Internet based updating capability (granted that has its own security issues). It also has an enclosure, which should help with print quality… This printer is also many times faster than my old one.

So far I have defined the device effectively in PrusaSlicer 2.7 as well as used Creality’s own slicer CrealityPrint to drive the device over the LAN and I have also gotten it up and running on CrealityCloud so I can slide and drive the printer from my cell phone.

I have printed a few complicated designs:

That picture is a toolbox lid created with PrusaSlicer’s organic supports, that took about 5 hours to print. Note that the lid is printed vertically, to increase the strength of the hinge mounts. The following is a slide from my Fusion and 3D printing class that I teach at our woodshop:

So far I am very happy with the printer and it is currently printing a Racko card holder in my garage.

Normally, a Racko card holder only goes up to 50 points. That one goes to 100.

The new sound circuit for the G gage train

A while back I mentioned a sound box for the G gage train that included flashing lights for the fire station. I took that circuit (without the flashing lights) and used the live edge box to make a relatively tiny sound box.

This is a breadbox layout of the circuit:

That image was created using a program called Fritzing, an open source electronics design tool. I had never used it before, but it definitely made the process of creating the breadboard picture easier than cut and paste in paint.

The code I ended up using looks like:

def isPlaying(): #routine to get the playing status
    statusBytes = [1,2,3]
    while len(statusBytes)!=10: #sometimes you get double status
        uart.write(STATUS_ARRAY) # ask for the status
        time.sleep(0.1) #give it some time 
        statusBytes = uart.read()
        time.sleep(0.1) #give it some time 
    if statusBytes[6] == 1:
        return True
    else:
        return False
        
from machine import Pin,UART
import time
#constant
UART_TX = 0
UART_RX = 1
ONBOARD_LED_GPx = 25
BUTTON_GPx = 13
DEBUG = False
## command to play the next sound
PLAY_ARRAY = bytearray(5)
PLAY_ARRAY[0] = 0x7E
PLAY_ARRAY[1] = 0xFF
PLAY_ARRAY[2] = 0x03
PLAY_ARRAY[3] = 0x01
PLAY_ARRAY[4] = 0xEF
## command to get status
STATUS_ARRAY = bytearray(5)
STATUS_ARRAY[0] = 0x7E
STATUS_ARRAY[1] = 0xFF
STATUS_ARRAY[2] = 0x03
STATUS_ARRAY[3] = 0x42
STATUS_ARRAY[4] = 0xEF
## command to define the device to play
DEVICE_ARRAY = bytearray(8)
DEVICE_ARRAY[0] = 0x7E
DEVICE_ARRAY[1] = 0xFF
DEVICE_ARRAY[2] = 0x06
DEVICE_ARRAY[3] = 0x09
DEVICE_ARRAY[4] = 0x00
DEVICE_ARRAY[5] = 0x00
DEVICE_ARRAY[6] = 0x02
DEVICE_ARRAY[7] = 0xEF
## command to set max volume
VOLUME_ARRAY = bytearray(8)
VOLUME_ARRAY[0] = 0x7E
VOLUME_ARRAY[1] = 0xFF
VOLUME_ARRAY[2] = 0x06
VOLUME_ARRAY[3] = 0x06
VOLUME_ARRAY[4] = 0x00
VOLUME_ARRAY[5] = 0x00
VOLUME_ARRAY[6] = 0x0E
VOLUME_ARRAY[7] = 0xEF
#variable
pressed = False # start out with the button unpressed
#device definition
uart = UART(0, baudrate=9600, tx=Pin(UART_TX), rx=Pin(UART_RX))
led_onboard = machine.Pin(ONBOARD_LED_GPx, machine.Pin.OUT)
button = machine.Pin(BUTTON_GPx, machine.Pin.IN, machine.Pin.PULL_UP)
#define a button handler
def button_handler(port):
    global pressed
    if not pressed:
        if DEBUG:
            print("need to press")
        pressed = True
        led_onboard.value(1) 
#main
uart.write(DEVICE_ARRAY)
time.sleep(0.2) # give it some time to read the data
uart.write(VOLUME_ARRAY)
time.sleep(0.2) # give it some time to read the data
uart.write(PLAY_ARRAY)
led_onboard.value(0) 
time.sleep(0.2)
#put the button handler in place
button.irq(trigger=machine.Pin.IRQ_RISING, handler=button_handler)
while True:
    if pressed:
        pressed = False # absorb the press
        led_onboard.value(0) 
        if DEBUG:
            print("button pressed") #debug
        if isPlaying():
            if DEBUG:
                print("debug: still playing")
            time.sleep(1)
        else:
            if DEBUG:
                print("debug: play another song")
            # looks like we can play another song
            uart.write(PLAY_ARRAY)
            time.sleep(1) #lets give it a rest
    else:
        time.sleep(1) #lets give it a rest
        if DEBUG:
            print("debug button not pressed") #debug

I left the debug code in there, since someone will likely need it if they want to play with this microFocus program on the Pico.

The design allows for loading in a number of MP3 files into the SD card and then having a different one play every time a button is pressed. The internal LED turns on while the program is handling the button press. It seems to be working, now I just need to assemble a few of them.

Using the live hinge

The G gage train that we have at our woodshop has sound automation that can be activated by pressing buttons. The kids who visit seem to like it. I always thought the 3D boxes to hold the electronics were always a bit klunky, held together with tape.

Now that I am using a UART controlled sound card, I thought I’d redesign the enclosure to have circuit, speaker, and connections in a self-locking box. There is one connector for the power and one for the switch interface.

The design now looks like:

The speaker will be on one side and the 3 small circuit boards (power converter, Pico and UART sound board) will be on the other. It should all close up nicely into a safe, relatively waterproof box.

I did the box design in Fusion and added the holes for the speaker and connectors with 3D builder. I could have done the whole thing in Fusion, but I find 3D builder quicker for rapid prototyping.

I am still using some buck coverters I had lying around, otherwise the design would be a bit narrower, though the speaker prevents it from getting too much smaller.

I’ll include a picture after the first one is done (if I can remember to update this post).

A parametric live hinge box model

I saw an article on creating live box hinges (hinges that bend to keep a box top and bottom attached when open). I took it as a challenge of my parametric design skills.

Live hinges have numerous advantages:

• Low-cost: Because of their simplicity, living hinges are cheap to make with 3D printing.

• Simplicity: Living hinges are integrated into parts, eliminating the need for extra components. The design can be easily altered.

They also have some issues:

• Durability: Since we are talking about extruded plastic here, multiple bending will cause fatigue and breakage over time.

• Appearance: They are not as subtle as a traditional hinge since the banded hinge sticks out of the design.

• Materials: The material you make the model out of needs to retain its flexibility over time. For example, PLA becomes brittle as it absorbs moisture from the air. I made mine out of PETG.

There are several approaches to the creation of live hinges:

• Hinged at the top with a relatively short hinge – requiring the design to be vertically oriented to print. This approach also has a relatively small area that takes all the stress.
• Hinged at the bottom with a longer hinge – this should allow for the design to be printed with maximum surface on the 3D printing plate. It also spreads stress over a wider area.

Since 3D printing is only strong in 2 dimensions, with the layered dimension significantly weaker, I decided to design for the longer, hinge at the bottom approach.

Fusion 360 supports parametric design, so I had to determine the critical dimensions that defined the design. These are what I ended up with:

The design itself is rather simple:

You can see from the design history (the timeline along the bottom) that there were not that many steps involved. When you change the boxLength, boxWidth or boxBaseHeight, the model updates to accommodate these new dimensions.

I learned a lot along the way since it took several iterations to get the model this simple. There are so many ways in Fusion 360 to accomplish a task that finding the optimal way can be a bit frustrating whenever you tackle a new approach.

Here are a couple of examples (note that they are different sizes):

The model is out in Thingiverse at:

Parametric live hinge box by cebess – Thingiverse

Prusa

I have continued to dig into the structures issue with 3D printing and REALLY wish these tools would export the structure as an STL file, rather than just G Code. I tell people there is no perfect hardware and there is no perfect software, so this just reinforces that perspective.

I did dust off Prusa slicer and set it up for my printer (I hope, since there are still a few questions about the setup process). It supports organic supports:

Now my big question is how well the structures will come apart…

I managed to print the bubble support

In the last post, I started to build the structures to support the complex blister struture. Here is a print in progress.

It managed to print OK, but the top structure was a bit thready (for lack of a better term), do to poor bridging. Note that the brim is almost touching between all the various elements. There is no way that it is going to pop off mid-print. I ended up creating the horizontal support structure every 10mm all the way up. It might be overkill but it is definitely cutting down on vibration.

This makes me want to research some of the more organic (or tree) scaffolding techniques that are described online. I have and use cura so I’ll give it a try and update what happens. My main goal is to have minimal support material consumed and maximum support for the horizontal plane located high above the plate.

It looks like it should be much faster but I am a little worried about those side supports going sooooo high without any kind of support. I may end up with a hybrid of hand made supports and the tree support.

Creating the supports to print this blister

As I delve into the issues of printing a structure as complex as the PBY blister, I need to build upon my existing knowledge of 3D printing sparce models. I learned long ago that when you are trying to print aerodynamic structures, it may be useful to split them in two and print the front separately from the back (especially if it has an irregular base). This allows the print to taper to the top of the print’s orientation.

I split the design at the widest point and then built a structure of columns that should break away.

Here is the support structure I have in the works now:

Note that I also printed a brim to keep the whole thing stable. The slicer generated support structures were a bit odd, and would take FOREVER to print, so I decided to hand build this one. The design approach was to create a set of columns in srategic weak areas. Once they were place, used a sketch to create several base plate/cross members that were 1mm thick between the columns that were the same height. I then used a repeating verticle pattern every 10-11 mm all the way up. The hope is to keep the support struture rigid enough to actually provide support, without consuming too much material. I don’t care how clean the spans/bridges are, since they are all getting thrown away. Here is a view (from a different angle) of the support struture in Fusion 360.

We’ll see how it prints, since this is a learning process. Looks like it will take 10 hours to complete, but I will probably know in about an hour (after it gets a couple of the stiffening structures done).

Catalina PBY Blister CAD effort

One of the folks in my neighborhood is really into RC modeling. He is building a fairly large version of a Catalina PBY.

One of the issues he ran into though was creating the blisters on the sides of the plane that were used for waste gunners. He knew I was into 3D printing as well as CAD efforts and since I am relatively homebound do to my wife being sick, I thought I’d take a crack at it using Fusion 360.

I am closing in on the design. I knew it was going to be hard, but what else do I have to work on right now. The model is about 300 mm long.

Now that the design is firming up though, printing something that open and curvy is going to be a real challenge. Any ideas? I have split the design so I can do a front and a back, but I am afraid I will also need to do a split at some point along the top and a bottom to address the complex Z axis layout as well. I need it to be able to lay flat on the bed, since I don’t have a multi-filiment printer. If I had one of those I’d probably try using a water soluable filament for the needed supporot.

Another ‘neon’ sign for the model railroad group

Earlier this year, I put out a post about creating 3D printed ‘neon’ open sign for the indoor train club in the neighborhood. Here is a link to a video of the open sign in operation.

We also have a large outdoor (G scale) train and they wanted an open sign. This sign had to be quite a bit larger but I finally got it done. Here is a photo of the letters before I created the electronics to drive them:

, and this is a video of this new sign in operation.

I used a Raspberry Pico as the controller. The following is the python code that drives it:

import machine
import time
# Define the GPIO pin to control the transistor
O_pin = machine.Pin(14, machine.Pin.OUT)
P_pin = machine.Pin(15, machine.Pin.OUT)
E_pin = machine.Pin(16, machine.Pin.OUT)
N_pin = machine.Pin(17, machine.Pin.OUT)
onboard_LED = machine.Pin(25, machine.Pin.OUT)
while True:
    # turn everything off
    O_pin.value(0)
    P_pin.value(0)
    E_pin.value(0)
    N_pin.value(0)
    onboard_LED(0)
    time.sleep(1)
    onboard_LED(1)
    # Turn on the transistor for the O
    O_pin.value(1)
    time.sleep(1)
    # Turn on the transistor for the P
    P_pin.value(1)
    time.sleep(1)
    # Turn on the transistor for the E
    E_pin.value(1)
    time.sleep(1)
    # Turn on the transistor for the N
    N_pin.value(1)
    time.sleep(1)
    # turn everything off
    O_pin.value(0)
    P_pin.value(0)
    E_pin.value(0)
    N_pin.value(0)
    time.sleep(1)
    # turn everything on
    O_pin.value(1)
    P_pin.value(1)
    E_pin.value(1)
    N_pin.value(1)
    time.sleep(1)
    # turn everything off
    O_pin.value(0)
    P_pin.value(0)
    E_pin.value(0)
    N_pin.value(0)
    time.sleep(1)
    # turn everything on
    O_pin.value(1)
    P_pin.value(1)
    E_pin.value(1)
    N_pin.value(1)
    time.sleep(1)
    
I wrote a class for our woodworking and modeling group that helps the folks get started in learning about the Pico and using it to automate models. This material was based off the documentation that came with the Pico but goes much further into interfaces to facilitate automation.