Input Shaping Damping

Damping
Fix spanish comments

src/libslic3r/GCode.cpp

@@ -3768,8 +3768,15 @@ LayerResult GCode::process_layer(
         writer().config.apply(_cfg);
         sprintf(buf, "; Calib_Retraction_tower: Z_HEIGHT: %g, length:%g\n", print_z, _length);
         gcode += buf;
-    } else if (print.calib_mode() == CalibMode::Calib_Input_shaping) {
+    } else if (print.calib_mode() == CalibMode::Calib_Input_shaping_freq) {
-        gcode += writer().set_input_shaping(m_layer_index < 2 ? 0.f : (print.calib_params().start) + ((print.calib_params().end)-(print.calib_params().start)) * (m_layer_index - 2) / (m_layer_count - 3), (print.calib_params().step));
+        gcode += writer().set_input_shaping('A', print.calib_params().step, m_layer_index < 2 ? 0.f : (print.calib_params().start) + ((print.calib_params().end)-(print.calib_params().start)) * (m_layer_index - 2) / (m_layer_count - 3));
+    } else if (print.calib_mode() == CalibMode::Calib_Input_shaping_damp) {
+        if (m_layer_index == 1){
+        gcode += writer().set_input_shaping('X', 0.f, print.calib_params().start);
+        gcode += writer().set_input_shaping('Y', 0.f, print.calib_params().end);
+        } else {
+        gcode += writer().set_input_shaping('A', float(m_layer_index) / float(m_layer_count), 0.f);
+        }
     }
 
     //BBS

src/libslic3r/GCodeWriter.cpp

@@ -333,21 +333,29 @@ std::string GCodeWriter::set_pressure_advance(double pa) const
     return gcode.str();
 }
 
-std::string GCodeWriter::set_input_shaping(float freq, float damp) const
+std::string GCodeWriter::set_input_shaping(char axis, float damp, float freq) const
 {
     std::ostringstream gcode;
     if (FLAVOR_IS(gcfKlipper))
     {
         throw std::runtime_error("M593 - ZV Input Shaping is NOT supported by Klipper");
     }
-    if (freq < 0.0f || damp < 0.f || damp > 1.0f)
+    if (freq < 0.0f || damp < 0.f || damp > 1.0f || (axis != 'X' && axis != 'Y' && axis != 'Z' && axis != 'A'))// A = all axis
     {
     throw std::runtime_error("Invalid input shaping parameters: freq=" + std::to_string(freq) + ", damp=" + std::to_string(damp));
     }
-    gcode << "M593  F" << freq;
+    gcode << "M593";
-    if (damp != 0.0f)
+    if (axis != 'A')
     {
-        gcode << " D" << damp;
+        gcode << " " << axis;
+    }
+    if (freq > 0.0f)
+    {
+        gcode << " F" << std::fixed << std::setprecision(2) << freq;
+    }
+    if (damp > 0.0f)
+    {
+        gcode << " D" << std::fixed << std::setprecision(2) << damp;
     }
     gcode << "; Override input shaping value\n";
     return gcode.str();

src/libslic3r/GCodeWriter.hpp

@@ -54,7 +54,7 @@ public:
     // Orca: set acceleration and jerk in one command for Klipper
     std::string set_accel_and_jerk(unsigned int acceleration, double jerk);
     std::string set_pressure_advance(double pa) const;
-    std::string set_input_shaping(float freq, float damp) const;
+    std::string set_input_shaping(char axis, float damp, float freq) const;
     std::string reset_e(bool force = false);
     std::string update_progress(unsigned int num, unsigned int tot, bool allow_100 = false) const;
     // return false if this extruder was already selected

src/libslic3r/calib.hpp

@@ -22,7 +22,8 @@ enum class CalibMode : int {
     Calib_Vol_speed_Tower,
     Calib_VFA_Tower,
     Calib_Retraction_tower,
-    Calib_Input_shaping
+    Calib_Input_shaping_freq,
+    Calib_Input_shaping_damp
 };
 
 enum class CalibState { Start = 0, Preset, Calibration, CoarseSave, FineCalibration, Save, Finish };

src/slic3r/GUI/CalibrationWizardSavePage.cpp

@@ -44,7 +44,9 @@ static wxString get_default_name(wxString filament_name, CalibMode mode){
         break;
     case Slic3r::CalibMode::Calib_Retraction_tower:
         break;
-    case Slic3r::CalibMode::Calib_Input_shaping:
+    case Slic3r::CalibMode::Calib_Input_shaping_freq:
+        break;
+    case Slic3r::CalibMode::Calib_Input_shaping_damp:
         break;
     default:
         break;

src/slic3r/GUI/MainFrame.cpp

@@ -2975,16 +2975,31 @@ void MainFrame::init_menubar_as_editor()
         "", nullptr,
         [this]() {return m_plater->is_view3D_shown();; }, this);
         
+    // Input Shaping calibrations
+    auto input_shaping_menu = new wxMenu();
+    
     append_menu_item(
-        advance_menu, wxID_ANY, _L("Input Shaping"), _L("Input Shaping"),
+        input_shaping_menu, wxID_ANY, _L("Input Shaping Frequency"), _L("Input Shaping Frequency"),
         [this](wxCommandEvent&) {
-            std::string url = "https://marlinfw.org/docs/gcode/M593.html";//TODO: Make OrcaSlicer wiki page
+            if (!m_IS_freq_calib_dlg)
-            if (!m_IS_calib_dlg)
+                m_IS_freq_calib_dlg = new Input_Shaping_Freq_Test_Dlg((wxWindow*)this, wxID_ANY, m_plater);
-                m_IS_calib_dlg = new Input_Shaping_Test_Dlg((wxWindow*)this, wxID_ANY, m_plater);
+            m_IS_freq_calib_dlg->ShowModal();
-            m_IS_calib_dlg->ShowModal();
         },
         "", nullptr,
         [this]() {return m_plater->is_view3D_shown();; }, this);
+        
+    append_menu_item(
+        input_shaping_menu, wxID_ANY, _L("Input Shaping Damping/zeta factor"), _L("Input Shaping Damping/zeta factor"),
+        [this](wxCommandEvent&) {
+            if (!m_IS_damp_calib_dlg)
+                m_IS_damp_calib_dlg = new Input_Shaping_Damp_Test_Dlg((wxWindow*)this, wxID_ANY, m_plater);
+            m_IS_damp_calib_dlg->ShowModal();
+        },
+        "", nullptr,
+        [this]() {return m_plater->is_view3D_shown();; }, this);
+    
+    m_topbar->GetCalibMenu()->AppendSubMenu(input_shaping_menu, _L("Input Shaping"));
+    
     m_topbar->GetCalibMenu()->AppendSubMenu(advance_menu, _L("More..."));
 
     // help 
@@ -3083,6 +3098,31 @@ void MainFrame::init_menubar_as_editor()
         }, "", nullptr,
         [this]() {return m_plater->is_view3D_shown();; }, this);    
        
+    // Input Shaping calibrations
+    auto input_shaping_menu = new wxMenu();
+    
+    append_menu_item(
+        input_shaping_menu, wxID_ANY, _L("Input Shaping Frequency"), _L("Input Shaping Frequency"),
+        [this](wxCommandEvent&) {
+            if (!m_IS_freq_calib_dlg)
+                m_IS_freq_calib_dlg = new Input_Shaping_Freq_Test_Dlg((wxWindow*)this, wxID_ANY, m_plater);
+            m_IS_freq_calib_dlg->ShowModal();
+        },
+        "", nullptr,
+        [this]() {return m_plater->is_view3D_shown();; }, this);
+        
+    append_menu_item(
+        input_shaping_menu, wxID_ANY, _L("Input Shaping Damping/zeta factor"), _L("Input Shaping Damping/zeta factor"),
+        [this](wxCommandEvent&) {
+            if (!m_IS_damp_calib_dlg)
+                m_IS_damp_calib_dlg = new Input_Shaping_Damp_Test_Dlg((wxWindow*)this, wxID_ANY, m_plater);
+            m_IS_damp_calib_dlg->ShowModal();
+        },
+        "", nullptr,
+        [this]() {return m_plater->is_view3D_shown();; }, this);
+    
+    calib_menu->AppendSubMenu(input_shaping_menu, _L("Input Shaping"));
+    
     append_submenu(calib_menu, advance_menu, wxID_ANY, _L("More..."), _L("More calibrations"), "",
         [this]() {return m_plater->is_view3D_shown();; });
     // help

src/slic3r/GUI/MainFrame.hpp

@@ -354,7 +354,8 @@ public:
     MaxVolumetricSpeed_Test_Dlg* m_vol_test_dlg { nullptr };
     VFA_Test_Dlg* m_vfa_test_dlg { nullptr };
     Retraction_Test_Dlg* m_retraction_calib_dlg{ nullptr };
-    Input_Shaping_Test_Dlg* m_IS_calib_dlg{ nullptr };
+    Input_Shaping_Freq_Test_Dlg* m_IS_freq_calib_dlg{ nullptr };
+    Input_Shaping_Damp_Test_Dlg* m_IS_damp_calib_dlg{ nullptr };
 
     // BBS. Replace title bar and menu bar with top bar.
     BBLTopbar*            m_topbar{ nullptr };

src/slic3r/GUI/Plater.cpp

@@ -10150,12 +10150,45 @@ void Plater::calib_VFA(const Calib_Params& params)
     p->background_process.fff_print()->set_calib_params(params);
 }
 
-void Plater::calib_input_shaping(const Calib_Params& params)
+void Plater::calib_input_shaping_freq(const Calib_Params& params)
 {
-    const auto calib_input_shaping_name = wxString::Format(L"Input shaping test");
+    const auto calib_input_shaping_name = wxString::Format(L"Input shaping Frequency test");
     new_project(false, false, calib_input_shaping_name);
     wxGetApp().mainframe->select_tab(size_t(MainFrame::tp3DEditor));
-    if (params.mode != CalibMode::Calib_Input_shaping)
+    if (params.mode != CalibMode::Calib_Input_shaping_freq)
+        return;
+
+    add_model(false, Slic3r::resources_dir() + "/calib/input_shaping/ringing_tower.stl");
+    auto print_config = &wxGetApp().preset_bundle->prints.get_edited_preset().config;
+    auto filament_config = &wxGetApp().preset_bundle->filaments.get_edited_preset().config;
+    filament_config->set_key_value("slow_down_layer_time", new ConfigOptionFloats { 2.0 });
+    filament_config->set_key_value("filament_max_volumetric_speed", new ConfigOptionFloats { 200 });
+    print_config->set_key_value("enable_overhang_speed", new ConfigOptionBool { false });
+    print_config->set_key_value("timelapse_type", new ConfigOptionEnum<TimelapseType>(tlTraditional));
+    print_config->set_key_value("wall_loops", new ConfigOptionInt(1));
+    print_config->set_key_value("top_shell_layers", new ConfigOptionInt(0));
+    print_config->set_key_value("bottom_shell_layers", new ConfigOptionInt(1));
+    print_config->set_key_value("sparse_infill_density", new ConfigOptionPercent(0));
+    print_config->set_key_value("spiral_mode", new ConfigOptionBool(true));
+    model().objects[0]->config.set_key_value("brim_type", new ConfigOptionEnum<BrimType>(btOuterOnly));
+    model().objects[0]->config.set_key_value("brim_width", new ConfigOptionFloat(3.0));
+    model().objects[0]->config.set_key_value("brim_object_gap", new ConfigOptionFloat(0.0));
+
+    changed_objects({ 0 });
+    wxGetApp().get_tab(Preset::TYPE_PRINT)->update_dirty();
+    wxGetApp().get_tab(Preset::TYPE_FILAMENT)->update_dirty();
+    wxGetApp().get_tab(Preset::TYPE_PRINT)->update_ui_from_settings();
+    wxGetApp().get_tab(Preset::TYPE_FILAMENT)->update_ui_from_settings();
+    
+    p->background_process.fff_print()->set_calib_params(params);
+}
+
+void Plater::calib_input_shaping_damp(const Calib_Params& params)
+{
+    const auto calib_input_shaping_name = wxString::Format(L"Input shaping Damping test");
+    new_project(false, false, calib_input_shaping_name);
+    wxGetApp().mainframe->select_tab(size_t(MainFrame::tp3DEditor));
+    if (params.mode != CalibMode::Calib_Input_shaping_damp)
         return;
 
     add_model(false, Slic3r::resources_dir() + "/calib/input_shaping/ringing_tower.stl");

src/slic3r/GUI/Plater.hpp

@@ -273,7 +273,8 @@ public:
     void calib_max_vol_speed(const Calib_Params& params);
     void calib_retraction(const Calib_Params& params);
     void calib_VFA(const Calib_Params& params);
-    void calib_input_shaping(const Calib_Params& params);
+    void calib_input_shaping_freq(const Calib_Params& params);
+    void calib_input_shaping_damp(const Calib_Params& params);
 
     BuildVolume_Type get_build_volume_type() const;
 

src/slic3r/GUI/calib_dlg.cpp

@@ -722,7 +722,7 @@ Retraction_Test_Dlg::Retraction_Test_Dlg(wxWindow* parent, wxWindowID id, Plater
     auto end_length_sizer = new wxBoxSizer(wxHORIZONTAL);
     auto end_length_text = new wxStaticText(this, wxID_ANY, end_length_str, wxDefaultPosition, st_size, wxALIGN_LEFT);
     m_tiEnd = new TextInput(this, std::to_string(2), _L("mm"), "", wxDefaultPosition, ti_size, wxTE_CENTRE);
-    m_tiEnd->GetTextCtrl()->SetValidator(wxTextValidator(wxFILTER_NUMERIC));//m_tiStart->GetTextCtrl()->SetValidator(wxTextValidator(wxFILTER_NUMERIC));//TODO: IANALEXIS CHECK
+    m_tiEnd->GetTextCtrl()->SetValidator(wxTextValidator(wxFILTER_NUMERIC));//m_tiStart->GetTextCtrl()->SetValidator(wxTextValidator(wxFILTER_NUMERIC));
     end_length_sizer->Add(end_length_text, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2);
     end_length_sizer->Add(m_tiEnd, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2);
     settings_sizer->Add(end_length_sizer);
@@ -789,11 +789,11 @@ void Retraction_Test_Dlg::on_dpi_changed(const wxRect& suggested_rect) {
 
 }
 
-// Input_Shaping_Test_Dlg
+// Input_Shaping_Freq_Test_Dlg
 //
 
-Input_Shaping_Test_Dlg::Input_Shaping_Test_Dlg(wxWindow* parent, wxWindowID id, Plater* plater)
+Input_Shaping_Freq_Test_Dlg::Input_Shaping_Freq_Test_Dlg(wxWindow* parent, wxWindowID id, Plater* plater)
-    : DPIDialog(parent, id, _L("Input shaping test"), wxDefaultPosition, parent->FromDIP(wxSize(-1, 280)), wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER), m_plater(plater)
+    : DPIDialog(parent, id, _L("Input shaping Frequency test"), wxDefaultPosition, parent->FromDIP(wxSize(-1, 280)), wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER), m_plater(plater)
 {
     wxBoxSizer* v_sizer = new wxBoxSizer(wxVERTICAL);
     SetSizer(v_sizer);
@@ -854,10 +854,10 @@ Input_Shaping_Test_Dlg::Input_Shaping_Test_Dlg(wxWindow* parent, wxWindowID id,
     m_btnStart->SetSize(wxSize(FromDIP(48), FromDIP(24)));
     m_btnStart->SetMinSize(wxSize(FromDIP(48), FromDIP(24)));
     m_btnStart->SetCornerRadius(FromDIP(3));
-    m_btnStart->Bind(wxEVT_BUTTON, &Input_Shaping_Test_Dlg::on_start, this);
+    m_btnStart->Bind(wxEVT_BUTTON, &Input_Shaping_Freq_Test_Dlg::on_start, this);
     v_sizer->Add(m_btnStart, 0, wxALL | wxALIGN_RIGHT, FromDIP(5));
 
-    m_btnStart->Connect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(Input_Shaping_Test_Dlg::on_start), NULL, this);
+    m_btnStart->Connect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(Input_Shaping_Freq_Test_Dlg::on_start), NULL, this);
 
     //wxGetApp().UpdateDlgDarkUI(this);//FIXME: dark mode background color
 
@@ -865,12 +865,12 @@ Input_Shaping_Test_Dlg::Input_Shaping_Test_Dlg(wxWindow* parent, wxWindowID id,
     Fit();
 }
 
-Input_Shaping_Test_Dlg::~Input_Shaping_Test_Dlg() {
+Input_Shaping_Freq_Test_Dlg::~Input_Shaping_Freq_Test_Dlg() {
     // Disconnect Events
-    m_btnStart->Disconnect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(Input_Shaping_Test_Dlg::on_start), NULL, this);
+    m_btnStart->Disconnect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(Input_Shaping_Freq_Test_Dlg::on_start), NULL, this);
 }
 
-void Input_Shaping_Test_Dlg::on_start(wxCommandEvent& event) {
+void Input_Shaping_Freq_Test_Dlg::on_start(wxCommandEvent& event) {
     bool read_double = false;
     read_double = m_tiStart->GetTextCtrl()->GetValue().ToDouble(&m_params.start);
     read_double = read_double && m_tiEnd->GetTextCtrl()->GetValue().ToDouble(&m_params.end);
@@ -879,7 +879,7 @@ void Input_Shaping_Test_Dlg::on_start(wxCommandEvent& event) {
     bool read_damping = m_tiDampingFactor->GetTextCtrl()->GetValue().ToDouble(&dampingFactor);
     
     if (!read_double || m_params.start < 0 || m_params.end > 500|| m_params.end < m_params.start) {
-        MessageDialog msg_dlg(nullptr, _L("Please input valid values:\nStart >= 0\nEnd <= 500\nStart < End"), wxEmptyString, wxICON_WARNING | wxOK);
+        MessageDialog msg_dlg(nullptr, _L("Please input valid values:\nStart > 0\nEnd < 500\nStart < End"), wxEmptyString, wxICON_WARNING | wxOK);
         msg_dlg.ShowModal();
         return;
     }
@@ -891,12 +891,104 @@ void Input_Shaping_Test_Dlg::on_start(wxCommandEvent& event) {
     }
 
     m_params.step = dampingFactor;
-    m_params.mode = CalibMode::Calib_Input_shaping;
+    m_params.mode = CalibMode::Calib_Input_shaping_freq;
-    m_plater->calib_input_shaping(m_params);
+    m_plater->calib_input_shaping_freq(m_params);
     EndModal(wxID_OK);
 }
 
-void Input_Shaping_Test_Dlg::on_dpi_changed(const wxRect& suggested_rect) {
+void Input_Shaping_Freq_Test_Dlg::on_dpi_changed(const wxRect& suggested_rect) {
+    this->Refresh();
+    Fit();
+
+}
+
+// Input_Shaping_Damp_Test_Dlg
+//
+
+Input_Shaping_Damp_Test_Dlg::Input_Shaping_Damp_Test_Dlg(wxWindow* parent, wxWindowID id, Plater* plater)
+    : DPIDialog(parent, id, _L("Input shaping Damp test"), wxDefaultPosition, parent->FromDIP(wxSize(-1, 280)), wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER), m_plater(plater)
+{
+    wxBoxSizer* v_sizer = new wxBoxSizer(wxVERTICAL);
+    SetSizer(v_sizer);
+
+   // Settings
+    //
+    wxString start_length_str = _L("X: ");
+    wxString end_length_str = _L("Y: ");
+    auto text_size = wxWindow::GetTextExtent(start_length_str);
+    text_size.IncTo(wxWindow::GetTextExtent(end_length_str));
+    text_size.x = text_size.x * 1.5;
+    wxStaticBoxSizer* settings_sizer = new wxStaticBoxSizer(wxVERTICAL, this, _L("Frequency settings"));
+
+    auto st_size = FromDIP(wxSize(text_size.x, -1));
+    auto ti_size = FromDIP(wxSize(90, -1));
+
+    auto start_length_sizer = new wxBoxSizer(wxHORIZONTAL);
+    auto start_length_text = new wxStaticText(this, wxID_ANY, start_length_str, wxDefaultPosition, st_size, wxALIGN_LEFT);
+    m_tiStart = new TextInput(this, std::to_string(40), _L("HZ"), "", wxDefaultPosition, ti_size, wxTE_CENTRE);
+    m_tiStart->GetTextCtrl()->SetValidator(wxTextValidator(wxFILTER_NUMERIC));
+    auto end_length_text = new wxStaticText(this, wxID_ANY, end_length_str, wxDefaultPosition, st_size, wxALIGN_LEFT);
+    m_tiEnd = new TextInput(this, std::to_string(40), _L("HZ"), "", wxDefaultPosition, ti_size, wxTE_CENTRE);
+    m_tiEnd->GetTextCtrl()->SetValidator(wxTextValidator(wxFILTER_NUMERIC));
+    
+    start_length_sizer->Add(start_length_text, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2);
+    start_length_sizer->Add(m_tiStart, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2);
+    start_length_sizer->Add(end_length_text, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2);
+    start_length_sizer->Add(m_tiEnd, 0, wxALL | wxALIGN_CENTER_VERTICAL, 2);
+    settings_sizer->Add(start_length_sizer);
+   
+    // Add a note to explain users to use their previously calculated frequency
+    auto note_text = new wxStaticText(this, wxID_ANY, _L("Note: Set frequencies to the previously calculated values"), 
+                                    wxDefaultPosition, wxDefaultSize, wxALIGN_LEFT);
+    note_text->SetForegroundColour(wxColour(128, 128, 128));
+    settings_sizer->Add(note_text, 0, wxALL, 5);
+
+    v_sizer->Add(settings_sizer);
+    v_sizer->Add(0, FromDIP(10), 0, wxEXPAND, 5);
+    m_btnStart = new Button(this, _L("OK"));
+    StateColor btn_bg_green(std::pair<wxColour, int>(wxColour(0, 137, 123), StateColor::Pressed),
+        std::pair<wxColour, int>(wxColour(38, 166, 154), StateColor::Hovered),
+        std::pair<wxColour, int>(wxColour(0, 150, 136), StateColor::Normal));
+
+    m_btnStart->SetBackgroundColor(btn_bg_green);
+    m_btnStart->SetBorderColor(wxColour(0, 150, 136));
+    m_btnStart->SetTextColor(wxColour("#FFFFFE"));
+    m_btnStart->SetSize(wxSize(FromDIP(48), FromDIP(24)));
+    m_btnStart->SetMinSize(wxSize(FromDIP(48), FromDIP(24)));
+    m_btnStart->SetCornerRadius(FromDIP(3));
+    m_btnStart->Bind(wxEVT_BUTTON, &Input_Shaping_Damp_Test_Dlg::on_start, this);
+    v_sizer->Add(m_btnStart, 0, wxALL | wxALIGN_RIGHT, FromDIP(5));
+
+    m_btnStart->Connect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(Input_Shaping_Damp_Test_Dlg::on_start), NULL, this);
+
+    //wxGetApp().UpdateDlgDarkUI(this);//FIXME: dark mode background color
+
+    Layout();
+    Fit();
+}
+
+Input_Shaping_Damp_Test_Dlg::~Input_Shaping_Damp_Test_Dlg() {
+    // Disconnect Events
+    m_btnStart->Disconnect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(Input_Shaping_Damp_Test_Dlg::on_start), NULL, this);
+}
+
+void Input_Shaping_Damp_Test_Dlg::on_start(wxCommandEvent& event) {
+    bool read_double = false;
+    read_double = m_tiStart->GetTextCtrl()->GetValue().ToDouble(&m_params.start);
+    read_double = read_double && m_tiEnd->GetTextCtrl()->GetValue().ToDouble(&m_params.end);
+        
+    if (!read_double || m_params.start < 0 || m_params.start > 500 || m_params.end < 0 || m_params.end > 500) {
+        MessageDialog msg_dlg(nullptr, _L("Please input valid values\n(0 < Freq < 500"), wxEmptyString, wxICON_WARNING | wxOK);
+        msg_dlg.ShowModal();
+        return;
+    }
+
+    m_params.mode = CalibMode::Calib_Input_shaping_damp;
+    m_plater->calib_input_shaping_damp(m_params);
+    EndModal(wxID_OK);
+}
+
+void Input_Shaping_Damp_Test_Dlg::on_dpi_changed(const wxRect& suggested_rect) {
     this->Refresh();
     Fit();
 

src/slic3r/GUI/calib_dlg.hpp

@@ -125,11 +125,11 @@ protected:
     Plater* m_plater;
 };
 
-class Input_Shaping_Test_Dlg : public DPIDialog
+class Input_Shaping_Freq_Test_Dlg : public DPIDialog
 {
 public:
-    Input_Shaping_Test_Dlg (wxWindow* parent, wxWindowID id, Plater* plater);
+    Input_Shaping_Freq_Test_Dlg (wxWindow* parent, wxWindowID id, Plater* plater);
-    ~Input_Shaping_Test_Dlg ();
+    ~Input_Shaping_Freq_Test_Dlg ();
     void on_dpi_changed(const wxRect& suggested_rect) override;
     
 protected:
@@ -144,5 +144,23 @@ protected:
     Plater* m_plater;
 };
 
+class Input_Shaping_Damp_Test_Dlg : public DPIDialog
+{
+public:
+    Input_Shaping_Damp_Test_Dlg (wxWindow* parent, wxWindowID id, Plater* plater);
+    ~Input_Shaping_Damp_Test_Dlg ();
+    void on_dpi_changed(const wxRect& suggested_rect) override;
+    
+protected:
+
+    virtual void on_start(wxCommandEvent& event);
+    Calib_Params m_params;
+
+    TextInput* m_tiStart;
+    TextInput* m_tiEnd;
+    Button* m_btnStart;
+    Plater* m_plater;
+};
+
 }} // namespace Slic3r::GUI
 #endif

src/slic3r/Utils/CalibUtils.cpp

@@ -57,8 +57,10 @@ std::string get_calib_mode_name(CalibMode cali_mode, int stage)
         return "vfa_tower_calib_mode";
     case CalibMode::Calib_Retraction_tower:
         return "retration_tower_calib_mode";
-    case CalibMode::Calib_Input_shaping:
+    case CalibMode::Calib_Input_shaping_freq:
-        return "input_shaping_calib_mode";
+        return "input_shaping_freq_calib_mode";
+    case CalibMode::Calib_Input_shaping_damp:
+        return "input_shaping_damp_calib_mode";
     default:
         assert(false);
         return "";
@@ -198,8 +200,10 @@ CalibMode CalibUtils::get_calib_mode_by_name(const std::string name, int& cali_s
         return CalibMode::Calib_VFA_Tower;
     else if (name == "retration_tower_calib_mode")
         return CalibMode::Calib_Retraction_tower;
-    else if (name == "input_shaping_calib_mode")
+    else if (name == "input_shaping_freq_calib_mode")
-        return CalibMode::Calib_Input_shaping;
+        return CalibMode::Calib_Input_shaping_freq;
+    else if (name == "input_shaping_damp_calib_mode")
+        return CalibMode::Calib_Input_shaping_damp;
     return CalibMode::Calib_None;
 }