Git Product home page Git Product logo

k1-hardware-mods's People

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

k1-hardware-mods's Issues

knomi issues

in the read me it says to follow btt info for the knomi but the required macro gave me errors and locked up my homing. what should we add to get the knomi to show all the different animations?

Macro integration for Homing and Leveling

Hello,

I have integrated a Knomi from BigTreeTech with your D3vil design head mount.

Actually in Knomi documentation they tell to add relevant macros for homing and bed leveling.
Unfortunatly those macro aren't working on K1 !

After some research i have finally make it work.

for homing, if you put macro as it, it will throw an error 'G28 is called recursively'.
I have found that come from macro defined in sensorless.cfg

So to make it work, first add the macro at end of file
[gcode_macro G28]
rename_existing: G0028
variable_homing:False
gcode:
RESPOND TYPE=command MSG='Custom G28 called'
SET_GCODE_VARIABLE MACRO=G28 VARIABLE=homing VALUE=True
G0028 {rawparams}
SET_GCODE_VARIABLE MACRO=G28 VARIABLE=homing VALUE=False

atfer what find _HOME_X, _HOME_Y and _HOME_Z macro and replace G28 in it by G0028 like this
[gcode_macro _HOME_X]
gcode:
_IF_MOVE_XY
{% if printer['gcode_macro xyz_ready'].x_ready|int == 1 %}
{% if (printer.configfile.settings['stepper_x'].position_max - printer.toolhead.position.x)|round < 10 %}
{% set x_park = (10 - (printer.configfile.settings['stepper_x'].position_max - printer.toolhead.position.x))|round %}
{% if x_park > 0 %}
G91
G1 x-{x_park} F3600
G90
G4 P1000
{% endif %}
{% endif %}
{% endif %}

# SET_TMC_FIELD FIELD=SGTHRS STEPPER=stepper_y VALUE=70
# SET_TMC_FIELD FIELD=SGTHRS STEPPER=stepper_x VALUE=70
# Home
RESPOND TYPE=command MSG='Call G28 in _HOME_X macro'
G0028 X #<<====== HERE
SET_GCODE_VARIABLE MACRO=xyz_ready VARIABLE=x_ready VALUE=1
# Move away
G91
G1 x-10 F3600
G90
# Wait just a second (give StallGuard registers time to clear)
G4 P2000

For bed leveling, as i'm using Kamp, in Adaptative_Meshing.cfg, BED_MESH_CALIBRATE Macro is already defined
So just add "variable_probing:False" after rename existing and SET_GCODE_VARIABLE before and after calling _BED_MESH_CALIBRATE

Here is the modified macro :
[gcode_macro BED_MESH_CALIBRATE]
rename_existing: _BED_MESH_CALIBRATE
variable_probing:False
gcode:

{% set all_points = printer.exclude_object.objects | map(attribute='polygon') | sum(start=[]) %}                                # Gather all object points
{% set bed_mesh_min = printer.configfile.settings.bed_mesh.mesh_min %}                                                          # Get bed mesh min from printer.cfg
{% set bed_mesh_max = printer.configfile.settings.bed_mesh.mesh_max %}                                                          # Get bed mesh max from printer.cfg
{% set probe_count = printer.configfile.settings.bed_mesh.probe_count %}                                                        # Get probe count from printer.cfg
{% set kamp_settings = printer["gcode_macro _KAMP_Settings"] %}                                                                 # Pull variables from _KAMP_Settings
{% set verbose_enable = kamp_settings.verbose_enable | abs %}                                                                   # Pull verbose setting from _KAMP_Settings
{% set probe_dock_enable = kamp_settings.probe_dock_enable | abs %}                                                             # Pull probe dockable probe settings from _KAMP_Settings
{% set attach_macro = kamp_settings.attach_macro | string %}                                                                    # Pull attach probe command from _KAMP_Settings
{% set detach_macro = kamp_settings.detach_macro | string %}                                                                    # Pull detach probe command from _KAMP_Settings
{% set mesh_margin = kamp_settings.mesh_margin | float %}                                                                       # Pull mesh margin setting from _KAMP_Settings
{% set fuzz_amount = kamp_settings.fuzz_amount | float %}                                                                       # Pull fuzz amount setting from _KAMP_Settings
{% set probe_count = probe_count if probe_count|length > 1 else probe_count * 2  %}                                             # If probe count is only a single number, convert it to 2. E.g. probe_count:7 = 7,7
{% set max_probe_point_distance_x = ( bed_mesh_max[0] - bed_mesh_min[0] ) / (probe_count[0] - 1)  %}                            # Determine max probe point distance
{% set max_probe_point_distance_y = ( bed_mesh_max[1] - bed_mesh_min[1] ) / (probe_count[1] - 1)  %}                            # Determine max probe point distance
{% set x_min = all_points | map(attribute=0) | min | default(bed_mesh_min[0]) %}                                                # Set x_min from smallest object x point
{% set y_min = all_points | map(attribute=1) | min | default(bed_mesh_min[1]) %}                                                # Set y_min from smallest object y point
{% set x_max = all_points | map(attribute=0) | max | default(bed_mesh_max[0]) %}                                                # Set x_max from largest object x point
{% set y_max = all_points | map(attribute=1) | max | default(bed_mesh_max[1]) %}                                                # Set y_max from largest object y point

{% set fuzz_range = range((0) | int, (fuzz_amount * 100) | int + 1) %}                                                          # Set fuzz_range between 0 and fuzz_amount
{% set adapted_x_min = x_min - mesh_margin - (fuzz_range | random / 100.0) %}                                                   # Adapt x_min to margin and fuzz constraints
{% set adapted_y_min = y_min - mesh_margin - (fuzz_range | random / 100.0) %}                                                   # Adapt y_min to margin and fuzz constraints
{% set adapted_x_max = x_max + mesh_margin + (fuzz_range | random / 100.0) %}                                                   # Adapt x_max to margin and fuzz constraints
{% set adapted_y_max = y_max + mesh_margin + (fuzz_range | random / 100.0) %}                                                   # Adapt y_max to margin and fuzz constraints

{% set adapted_x_min = [adapted_x_min , bed_mesh_min[0]] | max %}                                                               # Compare adjustments to defaults and choose max
{% set adapted_y_min = [adapted_y_min , bed_mesh_min[1]] | max %}                                                               # Compare adjustments to defaults and choose max
{% set adapted_x_max = [adapted_x_max , bed_mesh_max[0]] | min %}                                                               # Compare adjustments to defaults and choose min
{% set adapted_y_max = [adapted_y_max , bed_mesh_max[1]] | min %}                                                               # Compare adjustments to defaults and choose min

{% set points_x = (((adapted_x_max - adapted_x_min) / max_probe_point_distance_x) | round(method='ceil') | int) + 1 %}          # Define probe_count's x point count and round up
{% set points_y = (((adapted_y_max - adapted_y_min) / max_probe_point_distance_y) | round(method='ceil') | int) + 1 %}          # Define probe_count's y point count and round up

{% if (points_x > points_y) %}
    {% set points_y = points_x %}
{% endif %}

{% if (points_x < points_y) %}
    {% set points_x = points_y %}
{% endif %}

{% if (([points_x, points_y]|max) > 6) %}                                                                                       # 
    {% set algorithm = "bicubic" %}                                                                                             # 
    {% set min_points = 4 %}                                                                                                    # 
{% else %}                                                                                                                      # Calculate if algorithm should be bicubic or lagrange
    {% set algorithm = "lagrange" %}                                                                                            # 
    {% set min_points = 3 %}                                                                                                    # 
{% endif %}                                                                                                                     # 

{% set points_x = [points_x , min_points]|max %}                                                                                # Set probe_count's x points to fit the calculated algorithm
{% set points_y = [points_y , min_points]|max %}                                                                                # Set probe_count's y points to fit the calculated algorithm
{% set points_x = [points_x , probe_count[0]]|min %}
{% set points_y = [points_y , probe_count[1]]|min %}

{% if verbose_enable == True %}                                                                                                 # If verbose is enabled, print information about KAMP's calculations
    {% if printer.exclude_object.objects != [] %}

        { action_respond_info( "Algorithm: {}.".format(                                                                              
            (algorithm),                                                                                                            
        )) }

        { action_respond_info("Default probe count: {},{}.".format(                                                                  
            (probe_count[0]),                                                                                                       
            (probe_count[1]),                                                                                                       
        )) }

        { action_respond_info("Adapted probe count: {},{}.".format(                                                                  
            (points_x),                                                                                                             
            (points_y),                                                                                                             
        )) }                                                                                                              

        {action_respond_info("Default mesh bounds: {}, {}.".format(                                                                  
            (bed_mesh_min[0],bed_mesh_min[1]),                                                                                      
            (bed_mesh_max[0],bed_mesh_max[1]),                                                                                      
        )) }

        {% if mesh_margin > 0 %}                                                                                                    
            {action_respond_info("Mesh margin is {}, mesh bounds extended by {}mm.".format(                                       
                (mesh_margin),                                                                                                      
                (mesh_margin),                                                                                       
            )) }                                                                                                                    
        {% else %}                                                                                                                  
            {action_respond_info("Mesh margin is 0, margin not increased.")}                                                        
        {% endif %}                                                                                                                 

        {% if fuzz_amount > 0 %}                                                                                                    
            {action_respond_info("Mesh point fuzzing enabled, points fuzzed up to {}mm.".format(                                     
                (fuzz_amount),                                                                                                      
            )) }                                                                                                                    
        {% else %}                                                                                                                  
            {action_respond_info("Fuzz amount is 0, mesh points not fuzzed.")}                                                      
        {% endif %}                                                                                                                 

        { action_respond_info("Adapted mesh bounds: {}, {}.".format(                                                                 
            (adapted_x_min, adapted_y_min),                                                                                         
            (adapted_x_max, adapted_y_max),                                                                                         
        )) }

        {action_respond_info("KAMP adjustments successful. Happy KAMPing!")}

    {% else %}

        {action_respond_info("No objects detected! Check your gcode and make sure that EXCLUDE_OBJECT_DEFINE is happening before BED_MESH_CALIBRATE is called. Defaulting to regular meshing.")}
        G4 P5000                                                                                                                # Wait 5 seconds to make error more visible
    {% endif %}

{% endif %}

{% if probe_dock_enable == True %}
    {attach_macro}                                                                                                              # Attach/deploy a probe if the probe is stored somewhere outside of the print area
{% endif %}

SET_GCODE_VARIABLE MACRO=BED_MESH_CALIBRATE VARIABLE=probing VALUE=True
_BED_MESH_CALIBRATE mesh_min={adapted_x_min},{adapted_y_min} mesh_max={adapted_x_max},{adapted_y_max} ALGORITHM={algorithm} PROBE_COUNT={points_x},{points_y}
SET_GCODE_VARIABLE MACRO=BED_MESH_CALIBRATE VARIABLE=probing VALUE=False

{% if probe_dock_enable == True %}
    {detach_macro}                                                                                                              # Detach/stow a probe if the probe is stored somewhere outside of the print area
{% endif %}                                                                                                                     # End of verbose

Hope you'll find this usefull

"k1 xy joint v3.1.3mf" being flagged as Archive.Bomb by Baidu in VirusTotal

Hi Omran!

First off, thank you so much for all the assistance you've been offering the K1 community---I know that I, and a lot of other folks who have bought one, have honestly felt more supported and seen in the tutorial and mod videos that you've made, than by the support offered from Creality themselves. It can often be thankless, and dealing with Creality can be incredibly frustrating, so I want you to know that, at least for me, your videos are the ones I go to first whenever I'm having trouble with the printer, need to remember how something was put together, get ideas for improvements, etc.. And the music isn't bad, either ๐Ÿ˜Ž๏ธ๐Ÿ‘๏ธ

The work you've put into refining the movement system is the first major step forward into making the K1 a truly consistent and reliable print platform. Thank you so much!

I wanted to give you a heads up that for whatever reason, Baidu via VirusTotal is flagging the file "k1 xy joint v3.1.3mf" as an archive/zip bomb. I grabbed a couple random 3mf files from Printables with a similar size/number of compressed files, and scanned them to see if Baidu was flagging all 3mf files, but I only saw that behavior from the 3mf I got from your github repo.

I don't think it is intentional, and haven't flagged or reported the file to github or anything. My guess is that the easiest fix might be to try repacking the model into a new 3mf and re-uploading, but I'm not set up to test that sort of thing, so I can't say for sure.

Thank you again for the incredible help you've been to the K1 community!

-Su_Plx

How about adapating A new motherboard for Vanilla Klipper

How about adapting a new motherboard to be able to use Klipper Vanilla, I was thinking about one from Big Tree Tech, specifically a Manta 5P and using a 5-inch BTT SPI (or even HDMI) screen to use Klipperscreen. I have been analyzing the original motherboard but the CANBus parts and the Strain gauges are complicated for me. I hope you can help me.

Bearings

Hello,
great work from you and your Team/Partner what ever , glad that you give us such good impressions and information about the K1.
I have damaged my Bearing above the big idler over the Stepper motor , so i stopped the work and put the damaged back (he works but i think he will break soon ), do you know wich bearings are there in or which number they have ?

Other i have to disamble the printer again before i can purchase some new one.
Sry i know this is not the Issue with your design as itself, but perhaps you can help me :)

Regards

Gantry V2.0

image
Cant print the idlers are floating in midair

Can you potentially re up with them all split?

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    ๐Ÿ–– Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. ๐Ÿ“Š๐Ÿ“ˆ๐ŸŽ‰

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google โค๏ธ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.