Slic3r::Flashforge Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/Flashforge.hpp>

Inheritance diagram for Slic3r::Flashforge:

Collaboration diagram for Slic3r::Flashforge:

Public Types
typedef Http::ProgressFn	ProgressFn
typedef std::function< void(wxString)>	ErrorFn
typedef std::function< void(wxString, wxString)>	InfoFn

Public Member Functions
	Flashforge (DynamicPrintConfig *config)
	~Flashforge () override=default
const char *	get_name () const override
bool	test (wxString &curl_msg) const override
wxString	get_test_ok_msg () const override
wxString	get_test_failed_msg (wxString &msg) const override
bool	upload (PrintHostUpload upload_data, ProgressFn prorgess_fn, ErrorFn error_fn, InfoFn info_fn) const override
bool	has_auto_discovery () const override
bool	can_test () const override
PrintHostPostUploadActions	get_post_upload_actions () const override
std::string	get_host () const override
bool	fetch_material_slots (std::vector< FlashforgeMaterialSlot > &slots, bool *supports_material_station, wxString &msg) const
virtual bool	supports_multiple_printers () const
virtual std::string	get_sn () const
virtual bool	get_groups (wxArrayString &) const
virtual bool	get_printers (wxArrayString &) const
virtual bool	get_storage (wxArrayString &, wxArrayString &) const
virtual bool	is_cloud () const
virtual bool	is_logged_in () const
virtual void	log_out () const
virtual bool	get_login_url (wxString &auth_url) const

Static Public Member Functions
static bool	parse_material_slots (const std::string &body, std::vector< FlashforgeMaterialSlot > &slots, bool *supports_material_station)
static bool	discover_printers (std::vector< FlashforgeDiscoveredPrinter > &printers, wxString &msg, int timeout_ms=10000, int idle_timeout_ms=1500, int max_retries=3)
static PrintHost *	get_print_host (DynamicPrintConfig *config)
static std::string	get_print_host_webui (DynamicPrintConfig *config)
static int	get_err_code_from_body (const std::string &body)

Protected Member Functions
virtual wxString	format_error (const std::string &body, const std::string &error, unsigned status) const

Static Protected Member Functions
static wxString	timed_out_message ()

Private Member Functions
bool	upload_local_api (PrintHostUpload upload_data, ProgressFn progress_fn, ErrorFn error_fn) const
bool	test_local_api (wxString &msg) const
bool	request_local_api_json (const std::string &path, const std::string &body, std::string &response_body, wxString &error_msg) const
std::string	make_http_url (const std::string &path) const
std::string	extract_host_name () const
bool	connect (wxString &msg) const
bool	start_print (wxString &msg, const std::string &filename) const

Private Attributes
std::string	m_host
std::string	m_serial_number
std::string	m_check_code
std::string	m_console_port
const int	m_bufferSize
GCodeFlavor	m_gcFlavor
Slic3r::Utils::SerialMessage	controlCommand = {"~M601 S1\r\n",Slic3r::Utils::Command}
Slic3r::Utils::SerialMessage	connectKlipperCommand = {"~M640\r\n",Slic3r::Utils::Command}
Slic3r::Utils::SerialMessage	connectLegacyCommand = {"~M650\r\n",Slic3r::Utils::Command}
Slic3r::Utils::SerialMessage	nozzlePosCommand = {"~M114\r\n", Slic3r::Utils::Command}
Slic3r::Utils::SerialMessage	deviceInfoCommand = {"~M115\r\n", Slic3r::Utils::Command}
Slic3r::Utils::SerialMessage	statusCommand = {"~M119\r\n",Slic3r::Utils::Command}
Slic3r::Utils::SerialMessage	tempStatusCommand = {"~M105\r\n", Slic3r::Utils::Command}
Slic3r::Utils::SerialMessage	printStatusCommand = {"~M27\r\n", Slic3r::Utils::Command}
Slic3r::Utils::SerialMessage	saveFileCommand = {"~M29\r\n",Slic3r::Utils::Command}

Detailed Description

Member Typedef Documentation

ErrorFn

typedef std::function<void(wxString )> Slic3r::PrintHost::ErrorFn

inherited

InfoFn

typedef std::function<void(wxString , wxString )> Slic3r::PrintHost::InfoFn

inherited

ProgressFn

typedef Http::ProgressFn Slic3r::PrintHost::ProgressFn

inherited

Constructor & Destructor Documentation

Flashforge()

Slic3r::Flashforge::Flashforge ( DynamicPrintConfig * config )

explicit

    : m_host()
    , m_serial_number()
    , m_check_code()
    , m_console_port("8899")
    , m_gcFlavor(gcfMarlinLegacy)
    , m_bufferSize(4096) // 4K buffer size
{
    m_host          = safe_config_string(config, "print_host");
    m_serial_number = safe_config_string(config, "flashforge_serial_number");
    m_check_code    = safe_config_string(config, "printhost_apikey");
 
    if (config != nullptr) {
        if (const auto* gcode_flavor = config->option<ConfigOptionEnum<GCodeFlavor>>("gcode_flavor"); gcode_flavor != nullptr)
        m_gcFlavor = gcode_flavor->value;
    }
}

References Slic3r::gcfMarlinLegacy, Slic3r::gcode_flavor(), m_bufferSize, m_check_code, m_console_port, m_gcFlavor, m_host, m_serial_number, and Slic3r::ConfigBase::option().

Here is the call graph for this function:

~Flashforge()

Slic3r::Flashforge::~Flashforge ( )

overridedefault

Member Function Documentation

can_test()

bool Slic3r::Flashforge::can_test ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return true; }

connect()

bool Slic3r::Flashforge::connect ( wxString & msg ) const

private

{
    
    Utils::TCPConsole client(m_host, m_console_port);
 
    client.enqueue_cmd(controlCommand);
    client.enqueue_cmd(deviceInfoCommand);
 
    if (m_gcFlavor == gcfKlipper)
        client.enqueue_cmd(connectKlipperCommand);
    else {
        client.enqueue_cmd(connectLegacyCommand);
 
    }
 
    client.enqueue_cmd(statusCommand);
    
 
    bool res = client.run_queue();
 
    if (!res) {
        msg = wxString::FromUTF8(client.error_message().c_str());
        BOOST_LOG_TRIVIAL(info) << boost::format("[Flashforge Serial] Failed to initiate connection");
    } else
        BOOST_LOG_TRIVIAL(info) << boost::format("[Flashforge Serial] Successfully initiated Connection");
 
    return res;
}

References connectKlipperCommand, connectLegacyCommand, controlCommand, deviceInfoCommand, Slic3r::gcfKlipper, m_console_port, m_gcFlavor, m_host, and statusCommand.

Referenced by upload().

Here is the caller graph for this function:

discover_printers()

bool Slic3r::Flashforge::discover_printers ( std::vector< FlashforgeDiscoveredPrinter > & printers, wxString & msg, int timeout_ms = 10000, int idle_timeout_ms = 1500, int max_retries = 3 )

static

{
    printers.clear();
 
    try {
        const auto broadcast_addresses = get_discovery_broadcast_addresses();
        std::map<std::string, FlashforgeDiscoveredPrinter> by_ip;
 
        for (int attempt = 0; attempt < std::max(1, max_retries); ++attempt) {
            boost::asio::io_context      io_context;
            boost::asio::ip::udp::socket socket(io_context);
            boost::system::error_code    ec;
 
            socket.open(boost::asio::ip::udp::v4(), ec);
            if (ec) {
                msg = wxString::FromUTF8(ec.message().c_str());
                return false;
            }
 
            socket.set_option(boost::asio::socket_base::broadcast(true), ec);
            if (ec) {
                msg = wxString::FromUTF8(ec.message().c_str());
                return false;
            }
 
            socket.set_option(boost::asio::socket_base::reuse_address(true), ec);
            if (ec) {
                msg = wxString::FromUTF8(ec.message().c_str());
                return false;
            }
 
            socket.bind({boost::asio::ip::udp::v4(), FLASHFORGE_DISCOVERY_LISTEN_PORT}, ec);
            if (ec) {
                msg = wxString::FromUTF8(ec.message().c_str());
                return false;
            }
 
            for (const auto& addr : broadcast_addresses) {
                socket.send_to(boost::asio::buffer(FLASHFORGE_DISCOVERY_MESSAGE),
                               {boost::asio::ip::make_address_v4(addr, ec), FLASHFORGE_DISCOVERY_PORT}, 0, ec);
                ec.clear();
            }
 
            socket.non_blocking(true, ec);
            if (ec) {
                msg = wxString::FromUTF8(ec.message().c_str());
                return false;
            }
 
            const auto start      = std::chrono::steady_clock::now();
            auto       last_reply = start;
 
            while (true) {
                const auto now = std::chrono::steady_clock::now();
                if (std::chrono::duration_cast<std::chrono::milliseconds>(now - start).count() >= timeout_ms)
                    break;
                if (!by_ip.empty() && std::chrono::duration_cast<std::chrono::milliseconds>(now - last_reply).count() >= idle_timeout_ms)
                    break;
 
                std::vector<unsigned char> buffer(512);
                boost::asio::ip::udp::endpoint remote_endpoint;
                const auto received = socket.receive_from(boost::asio::buffer(buffer), remote_endpoint, 0, ec);
                if (!ec) {
                    buffer.resize(received);
                    FlashforgeDiscoveredPrinter printer;
                    if (parse_discovery_response(buffer, remote_endpoint.address().to_string(), printer)) {
                        by_ip[printer.ip_address] = std::move(printer);
                        last_reply               = std::chrono::steady_clock::now();
                    }
                } else if (ec == boost::asio::error::would_block || ec == boost::asio::error::try_again) {
                    ec.clear();
                    std::this_thread::sleep_for(std::chrono::milliseconds(50));
                } else {
                    msg = wxString::FromUTF8(ec.message().c_str());
                    return false;
                }
            }
 
            if (!by_ip.empty())
                break;
        }
 
        for (auto& [_, printer] : by_ip)
            printers.emplace_back(std::move(printer));
 
        std::sort(printers.begin(), printers.end(), [](const FlashforgeDiscoveredPrinter& lhs, const FlashforgeDiscoveredPrinter& rhs) {
            if (lhs.name != rhs.name)
                return lhs.name < rhs.name;
            return lhs.ip_address < rhs.ip_address;
        });
 
        if (printers.empty()) {
            msg = _(L("No Flashforge printers were discovered on the local network."));
            return false;
        }
 
        return true;
    } catch (const std::exception& ex) {
        msg = wxString::FromUTF8(ex.what());
        return false;
    }
}

References _, count, Slic3r::FlashforgeDiscoveredPrinter::ip_address, and L.

Referenced by Slic3r::GUI::PhysicalPrinterDialog::build_printhost_settings().

Here is the caller graph for this function:

extract_host_name()

std::string Slic3r::Flashforge::extract_host_name ( ) const

private

{
    std::string host = m_host;
    if (host.find("://") == std::string::npos) {
        const auto slash_pos = host.find('/');
        if (slash_pos != std::string::npos)
            host = host.substr(0, slash_pos);
        return host;
    }
 
    std::string out = host;
    CURLU*       hurl = curl_url();
    if (!hurl)
        return host;
 
    const auto rc = curl_url_set(hurl, CURLUPART_URL, host.c_str(), 0);
    if (rc == CURLUE_OK) {
        char* raw_host = nullptr;
        if (curl_url_get(hurl, CURLUPART_HOST, &raw_host, 0) == CURLUE_OK && raw_host != nullptr) {
            out = raw_host;
            curl_free(raw_host);
        }
    }
 
    curl_url_cleanup(hurl);
    return out;
}

References m_host.

Referenced by make_http_url().

Here is the caller graph for this function:

fetch_material_slots()

bool Slic3r::Flashforge::fetch_material_slots	(	std::vector< FlashforgeMaterialSlot > &	slots,
		bool *	supports_material_station,
		wxString &	msg ) const

{
    slots.clear();
 
    if (m_serial_number.empty() || m_check_code.empty()) {
        msg = _(L("Flashforge local API requires both serial number and access code."));
        return false;
    }
 
    std::string body;
    if (!request_local_api_json("detail", json{{"serialNumber", m_serial_number}, {"checkCode", m_check_code}}.dump(), body, msg))
        return false;
 
    if (!parse_material_slots(body, slots, supports_material_station)) {
        msg = _(L("Flashforge returned an invalid JSON response."));
        return false;
    }
 
    return true;
}

References _, L, m_check_code, m_serial_number, parse_material_slots(), and request_local_api_json().

Here is the call graph for this function:

format_error()

wxString Slic3r::PrintHost::format_error ( const std::string & body, const std::string & error, unsigned status ) const

protectedvirtualinherited

{
    if (status != 0) {
        const std::string reason = moonraker_error_reason(body);
        auto wxbody = wxString::FromUTF8(reason.empty() ? body : reason);
        return wxString::Format("HTTP %u: %s", status, wxbody);
    } else {
        if (error.find("curl:Timeout was reached") != std::string::npos) {
            return timed_out_message();
        }else if(error.find("curl:Couldn't resolve host name")!= std::string::npos){
            return _L("The Hostname/IP/URL could not be parsed, please check it and try again.");
        } else if (error.find("Connection was reset") != std::string::npos){
            return _L("File/data transfer interrupted. Please check the printer and network, then try it again.");
        }
        else {
            return wxString::FromUTF8(error.data());
        }
    }
}

References _L, and timed_out_message().

Referenced by Slic3r::Duet::connect(), Slic3r::UltiMaker::connect(), Slic3r::SimplyPrint::do_chunk_upload(), Slic3r::SimplyPrint::do_temp_upload(), Slic3r::ElegooLink::elegoo_cc2_test(), Slic3r::ElegooLink::elegoo_test(), Slic3r::PrusaLink::post_inner(), Slic3r::PrusaLink::put_inner(), Slic3r::Flashforge::request_local_api_json(), Slic3r::Duet::start_print(), Slic3r::Moonraker::start_print(), Slic3r::UltiMaker::start_print(), Slic3r::AstroBox::test(), Slic3r::CrealityPrint::test(), Slic3r::ESP3D::test(), Slic3r::FlashAir::test(), Slic3r::Moonraker::test(), Slic3r::Obico::test(), Slic3r::OctoPrint::test(), Slic3r::PrusaLink::test(), Slic3r::Repetier::test(), Slic3r::UltiMaker::test(), Slic3r::PrusaLink::test_with_method_check(), Slic3r::AstroBox::upload(), Slic3r::C3DPrinterOS::upload(), Slic3r::CrealityPrint::upload(), Slic3r::Duet::upload(), Slic3r::ESP3D::upload(), Slic3r::FlashAir::upload(), Slic3r::MKS::upload(), Slic3r::Moonraker::upload(), Slic3r::Obico::upload(), Slic3r::Repetier::upload(), Slic3r::UltiMaker::upload(), Slic3r::OctoPrint::upload_inner_with_host(), Slic3r::Flashforge::upload_local_api(), Slic3r::ElegooLink::uploadPart(), and Slic3r::ElegooLink::uploadPartCC2().

Here is the call graph for this function:

Here is the caller graph for this function:

get_err_code_from_body()

int Slic3r::PrintHost::get_err_code_from_body ( const std::string & body )

staticinherited

{
    boost::property_tree::ptree root;
    std::istringstream iss(body);
    try {
        boost::property_tree::read_json(iss, root);
    } catch (const std::exception &ex) {
        BOOST_LOG_TRIVIAL(error) << "PrintHost: response is not valid JSON: " << ex.what();
        return -1;
    }
 
    return root.get<int>("err", 0);
}

Referenced by Slic3r::Duet::connect(), Slic3r::UltiMaker::connect(), Slic3r::Duet::upload(), Slic3r::MKS::upload(), and Slic3r::UltiMaker::upload().

Here is the caller graph for this function:

get_groups()

virtual bool Slic3r::PrintHost::get_groups ( wxArrayString & ) const

inlinevirtualinherited

Reimplemented in Slic3r::Repetier.

{ return false; }

get_host()

std::string Slic3r::Flashforge::get_host ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return m_host; }

References m_host.

get_login_url()

virtual bool Slic3r::PrintHost::get_login_url ( wxString & auth_url ) const

inlinevirtualinherited

Reimplemented in Slic3r::Obico.

{ return false; }

Referenced by Slic3r::GUI::PrinterCloudAuthDialog::PrinterCloudAuthDialog().

Here is the caller graph for this function:

get_name()

const char * Slic3r::Flashforge::get_name ( ) const

overridevirtual

Implements Slic3r::PrintHost.

{ return "Flashforge"; }

get_post_upload_actions()

PrintHostPostUploadActions Slic3r::Flashforge::get_post_upload_actions ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return PrintHostPostUploadAction::StartPrint; }

References Slic3r::StartPrint.

get_print_host()

PrintHost * Slic3r::PrintHost::get_print_host ( DynamicPrintConfig * config )

staticinherited

{
    PrinterTechnology tech = ptFFF;
 
    {
        const auto opt = config->option<ConfigOptionEnum<PrinterTechnology>>("printer_technology");
        if (opt != nullptr) {
            tech = opt->value;
        }
    }
 
    if (tech == ptFFF) {
        const auto opt = config->option<ConfigOptionEnum<PrintHostType>>("host_type");
        const auto host_type = opt != nullptr ? opt->value : htOctoPrint;
 
        switch (host_type) {
            case htOctoPrint: return new OctoPrint(config);
            case htDuet:      return new Duet(config);
            case htUltiMaker: return new UltiMaker(config);
            case htFlashAir:  return new FlashAir(config);
            case htAstroBox:  return new AstroBox(config);
            case htRepetier:  return new Repetier(config);
            case htPrusaLink: return new PrusaLink(config);
            case htPrusaConnect: return new PrusaConnect(config);
            case htMKS:       return new MKS(config);
            case htESP3D:       return new ESP3D(config);
            case htCrealityPrint:    return new CrealityPrint(config);
            case htObico:     return new Obico(config);
            case htFlashforge: return new Flashforge(config);
            case htSimplyPrint: return new SimplyPrint(config);
            case htElegooLink: return new ElegooLink(config);
            case ht3DPrinterOS: return new C3DPrinterOS(config);
            case htMoonraker: return new Moonraker(config);
            default:          return nullptr;
        }
    } else {
        return new SL1Host(config);
    }
}

References Slic3r::ht3DPrinterOS, Slic3r::htAstroBox, Slic3r::htCrealityPrint, Slic3r::htDuet, Slic3r::htElegooLink, Slic3r::htESP3D, Slic3r::htFlashAir, Slic3r::htFlashforge, Slic3r::htMKS, Slic3r::htMoonraker, Slic3r::htObico, Slic3r::htOctoPrint, Slic3r::htPrusaConnect, Slic3r::htPrusaLink, Slic3r::htRepetier, Slic3r::htSimplyPrint, Slic3r::htUltiMaker, Slic3r::ConfigBase::option(), and Slic3r::ptFFF.

Referenced by Slic3r::GUI::PhysicalPrinterDialog::build_printhost_settings(), Slic3r::GUI::anonymous_namespace{PrinterWebViewHandler.cpp}::ElegooPrinterWebViewHandler::handle_get_sn_request(), Slic3r::GUI::anonymous_namespace{PrinterWebViewHandler.cpp}::ElegooPrinterWebViewHandler::handle_upload_request(), Slic3r::GUI::PhysicalPrinterDialog::update_printers(), and Slic3r::GUI::PhysicalPrinterDialog::update_printhost_buttons().

Here is the call graph for this function:

Here is the caller graph for this function:

get_print_host_webui()

std::string Slic3r::PrintHost::get_print_host_webui ( DynamicPrintConfig * config )

staticinherited

{
    if (config == nullptr)
        return {};
 
    std::string webui_url;
    const auto* host_type_opt = config->option<ConfigOptionEnum<PrintHostType>>("host_type");
    const auto  host_type     = host_type_opt != nullptr ? host_type_opt->value : htOctoPrint;
 
    switch (host_type) {
    case htElegooLink: {
        webui_url = ElegooLink::get_print_host_webui(config);
        break;
    }
    default: break;
    }
 
    if (webui_url.empty()) {
        webui_url = config->opt_string("print_host_webui");
        if (webui_url.empty())
            webui_url = config->opt_string("print_host");
        if (webui_url.empty())
            return webui_url;
    }
 
    const bool has_http_scheme = boost::algorithm::istarts_with(webui_url, "http");
    const bool has_file_scheme = boost::algorithm::istarts_with(webui_url, "file:");
 
    if (!has_http_scheme && !has_file_scheme)
        webui_url = "http://" + webui_url;
 
    return webui_url;
}

References Slic3r::ElegooLink::get_print_host_webui(), Slic3r::htElegooLink, Slic3r::htOctoPrint, Slic3r::DynamicConfig::opt_string(), Slic3r::ConfigBase::option(), and Slic3r::ConfigOptionSingle< T >::value.

Referenced by Slic3r::GUI::MainFrame::load_printer_url(), Slic3r::GUI::Plater::priv::on_tab_selection_changing(), and Slic3r::GUI::Sidebar::update_all_preset_comboboxes().

Here is the call graph for this function:

Here is the caller graph for this function:

get_printers()

virtual bool Slic3r::PrintHost::get_printers ( wxArrayString & ) const

inlinevirtualinherited

Reimplemented in Slic3r::Obico, and Slic3r::Repetier.

{ return false; }

get_sn()

virtual std::string Slic3r::PrintHost::get_sn ( ) const

inlinevirtualinherited

Get the serial number for connecting to the printer. For Elegoo CC2, the device details connection to the printer requires the serial number. Other print hosts do not need to implement this interface, and it returns an empty string by default.

Reimplemented in Slic3r::ElegooLink.

{ return ""; }

get_storage()

virtual bool Slic3r::PrintHost::get_storage ( wxArrayString & , wxArrayString &  ) const

inlinevirtualinherited

Reimplemented in Slic3r::Moonraker, Slic3r::PrusaConnect, and Slic3r::PrusaLink.

{ return false; }

get_test_failed_msg()

wxString Slic3r::Flashforge::get_test_failed_msg ( wxString & msg ) const

overridevirtual

Implements Slic3r::PrintHost.

{
    const std::string prefix = (!m_serial_number.empty() && !m_check_code.empty()) ?
        _utf8(L("Could not connect to Flashforge local API")) :
        _utf8(L("Could not connect to Flashforge via serial"));
    return GUI::from_u8((boost::format("%s: %s") % prefix % std::string(msg.ToUTF8())).str());
}

References _utf8, Slic3r::GUI::from_u8(), L, m_check_code, and m_serial_number.

Here is the call graph for this function:

get_test_ok_msg()

wxString Slic3r::Flashforge::get_test_ok_msg ( ) const

overridevirtual

Implements Slic3r::PrintHost.

{
    if (!m_serial_number.empty() && !m_check_code.empty())
        return _(L("Connected to Flashforge local API successfully."));
    return _(L("Serial connection to Flashforge is working correctly."));
}

References _, L, m_check_code, and m_serial_number.

has_auto_discovery()

bool Slic3r::Flashforge::has_auto_discovery ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return true; }

is_cloud()

virtual bool Slic3r::PrintHost::is_cloud ( ) const

inlinevirtualinherited

Reimplemented in Slic3r::C3DPrinterOS, Slic3r::Obico, and Slic3r::SimplyPrint.

{ return false; }

is_logged_in()

virtual bool Slic3r::PrintHost::is_logged_in ( ) const

inlinevirtualinherited

Reimplemented in Slic3r::C3DPrinterOS, and Slic3r::SimplyPrint.

{ return false; }

log_out()

virtual void Slic3r::PrintHost::log_out ( ) const

inlinevirtualinherited

Reimplemented in Slic3r::C3DPrinterOS, and Slic3r::SimplyPrint.

{}

make_http_url()

std::string Slic3r::Flashforge::make_http_url ( const std::string & path ) const

private

{
    return (boost::format("http://%1%:8898/%2%") % extract_host_name() % path).str();
}

References extract_host_name().

Referenced by request_local_api_json(), and upload_local_api().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_material_slots()

bool Slic3r::Flashforge::parse_material_slots ( const std::string & body, std::vector< FlashforgeMaterialSlot > & slots, bool * supports_material_station )

static

{
    slots.clear();
 
    const auto parsed = json::parse(body, nullptr, false, true);
    if (parsed.is_discarded())
        return false;
 
    const auto& detail = parsed.contains("detail") ? parsed["detail"] : parsed;
    const auto& station = detail.contains("matlStationInfo") ? detail["matlStationInfo"] :
                          detail.contains("MatlStationInfo") ? detail["MatlStationInfo"] : json();
    const auto& slot_infos = station.contains("slotInfos") ? station["slotInfos"] :
                             station.contains("SlotInfos") ? station["SlotInfos"] : json::array();
 
    bool reports_material_station = false;
 
    int has_material_station_flag = 0;
    if (detail.contains("hasMatlStation") && try_parse_json_int(detail["hasMatlStation"], has_material_station_flag))
        reports_material_station = has_material_station_flag != 0;
    else if (detail.contains("HasMatlStation") && try_parse_json_int(detail["HasMatlStation"], has_material_station_flag))
        reports_material_station = has_material_station_flag != 0;
 
    int slot_count = 0;
    if (station.contains("slotCnt") && try_parse_json_int(station["slotCnt"], slot_count))
        reports_material_station = reports_material_station || slot_count > 0;
    else if (station.contains("SlotCnt") && try_parse_json_int(station["SlotCnt"], slot_count))
        reports_material_station = reports_material_station || slot_count > 0;
 
    if (slot_infos.is_array() && !slot_infos.empty())
        reports_material_station = true;
 
    if (supports_material_station != nullptr)
        *supports_material_station = reports_material_station;
 
    // Fields are read leniently: firmware may send numbers as strings or flags as numbers.
    for (const auto& slot : slot_infos) {
        if (!slot.is_object())
            continue;
        FlashforgeMaterialSlot info;
        info.slot_id = static_cast<int>(slots.size()) + 1;
        if (const auto it = slot.find("slotId"); it != slot.end())
            try_parse_json_int(*it, info.slot_id);
        int has_filament = 0;
        if (const auto it = slot.find("hasFilament"); it != slot.end() && try_parse_json_int(*it, has_filament))
            info.has_filament = has_filament != 0;
        if (const auto it = slot.find("materialName"); it != slot.end() && it->is_string())
            info.material_name = it->get<std::string>();
        if (const auto it = slot.find("materialColor"); it != slot.end() && it->is_string())
            info.material_color = it->get<std::string>();
        slots.emplace_back(std::move(info));
    }
 
    return true;
}

References Slic3r::FlashforgeMaterialSlot::has_filament, Slic3r::FlashforgeMaterialSlot::material_color, Slic3r::FlashforgeMaterialSlot::material_name, and Slic3r::FlashforgeMaterialSlot::slot_id.

Referenced by fetch_material_slots().

Here is the caller graph for this function:

request_local_api_json()

bool Slic3r::Flashforge::request_local_api_json ( const std::string & path, const std::string & body, std::string & response_body, wxString & error_msg ) const

private

{
    bool ok = true;
    auto http = Http::post(make_http_url(path));
    http.header("Content-Type", "application/json")
        .set_post_body(body)
        .on_complete([&](std::string body_text, unsigned) {
            response_body = std::move(body_text);
            if (!validate_local_api_response(response_body, error_msg))
                ok = false;
        })
        .on_error([&](std::string body_text, std::string error, unsigned status) {
            response_body = std::move(body_text);
            error_msg     = format_error(response_body, error, status);
            ok            = false;
        })
        .perform_sync();
    return ok;
}

References Slic3r::PrintHost::format_error(), Slic3r::http, make_http_url(), and Slic3r::Http::post().

Referenced by fetch_material_slots(), and test_local_api().

Here is the call graph for this function:

Here is the caller graph for this function:

start_print()

bool Slic3r::Flashforge::start_print ( wxString & msg, const std::string & filename ) const

private

{
    Utils::TCPConsole            client(m_host, m_console_port);
    const std::string            safe_filename = sanitize_flashforge_filename(filename);
    Slic3r::Utils::SerialMessage startPrintCommand = {(boost::format("~M23 0:/user/%1%") % safe_filename).str(), Slic3r::Utils::Command};
    client.enqueue_cmd(startPrintCommand);
    bool res = client.run_queue();
 
    if (!res) {
        msg = wxString::FromUTF8(client.error_message().c_str());
        BOOST_LOG_TRIVIAL(info) << boost::format("[Flashforge Serial] Failed to start print %1%") % safe_filename;
    } else
        BOOST_LOG_TRIVIAL(info) << boost::format("[Flashforge Serial] Started print %1%") % safe_filename;
 
    return res;
}

References Slic3r::Utils::Command, m_console_port, and m_host.

Referenced by upload().

Here is the caller graph for this function:

supports_multiple_printers()

virtual bool Slic3r::PrintHost::supports_multiple_printers ( ) const

inlinevirtualinherited

Reimplemented in Slic3r::Repetier.

{ return false; }

test()

bool Slic3r::Flashforge::test ( wxString & curl_msg ) const

overridevirtual

Implements Slic3r::PrintHost.

{
    if (!m_serial_number.empty() && !m_check_code.empty())
        return test_local_api(msg);
 
    BOOST_LOG_TRIVIAL(debug) << boost::format("[Flashforge Serial] testing connection");
    // Utils::TCPConsole console(m_host, m_console_port);
    Utils::TCPConsole client(m_host, m_console_port);
    client.enqueue_cmd(controlCommand);
    bool res = client.run_queue();
    if (!res) {
        msg = wxString::FromUTF8(client.error_message().c_str());
        BOOST_LOG_TRIVIAL(info) << boost::format("[Flashforge Serial] testing connection failed");
    } else {
        BOOST_LOG_TRIVIAL(info) << boost::format("[Flashforge Serial] testing connection success");
    }
    return res;
}

References controlCommand, m_check_code, m_console_port, m_host, m_serial_number, and test_local_api().

Here is the call graph for this function:

test_local_api()

bool Slic3r::Flashforge::test_local_api ( wxString & msg ) const

private

{
    std::string body;
    return request_local_api_json("detail", json{{"serialNumber", m_serial_number}, {"checkCode", m_check_code}}.dump(), body, msg);
}

References m_check_code, m_serial_number, and request_local_api_json().

Referenced by test().

Here is the call graph for this function:

Here is the caller graph for this function:

timed_out_message()

wxString Slic3r::PrintHost::timed_out_message ( )

staticprotectedinherited

{
    return _L("Connection timed out. Please check if the printer and computer network are functioning properly, and confirm that they are on the same network.");
}

References _L.

Referenced by format_error(), and Slic3r::CrealityPrint::start_print().

Here is the caller graph for this function:

upload()

bool Slic3r::Flashforge::upload ( PrintHostUpload upload_data, ProgressFn prorgess_fn, ErrorFn error_fn, InfoFn info_fn ) const

overridevirtual

Implements Slic3r::PrintHost.

{
    if (!m_serial_number.empty() && !m_check_code.empty())
        return upload_local_api(std::move(upload_data), std::move(progress_fn), std::move(error_fn));
 
    bool res = true;
    wxString errormsg;
 
    Utils::TCPConsole client(m_host, m_console_port);
 
    try {
 
        res = connect(errormsg);
        const std::string fallback_extension = upload_data.source_path.extension().string().empty() ? ".gcode" : upload_data.source_path.extension().string();
        const std::string upload_filename = sanitize_flashforge_filename(upload_data.upload_path.string(), fallback_extension);
 
        std::ifstream newfile;
        newfile.open(upload_data.source_path.c_str(), std::ios::binary); // open a file to perform read operation using file object
        std::string gcodeFile;
        if (newfile.is_open()) {                                         // checking whether the file is open
            BOOST_LOG_TRIVIAL(info) << boost::format("[Flashforge Serial] Reading file...");
            newfile.seekg(0, std::ios::end);
            std::ifstream::pos_type pos = newfile.tellg();
 
            std::vector<char> result(pos);
 
            newfile.seekg(0, std::ios::beg);
            newfile.read(&result[0], pos);
 
            gcodeFile = std::string(result.begin(), result.end()); // TODO: Find more efficient way of breaking ifstream
 
            BOOST_LOG_TRIVIAL(info) << boost::format("[Flashforge Serial] Reading file...done size is %1%") % gcodeFile.size();
 
            newfile.close(); // close the file object.
        }
        Slic3r::Utils::SerialMessage fileuploadCommand =
            {(boost::format("~M28 %1% 0:/user/%2%") % gcodeFile.size() % upload_filename).str(),
             Slic3r::Utils::Command};
        client.enqueue_cmd(fileuploadCommand);
 
        //client.set_tcp_queue_delay(std::chrono::nanoseconds(10000));
 
        for (int bytePos = 0; bytePos < gcodeFile.size(); bytePos += m_bufferSize) { // TODO: Find more efficient way of breaking ifstream
 
            int bytePosEnd  = (gcodeFile.size() - bytePos > m_bufferSize - 1) ? m_bufferSize : gcodeFile.size();
            Slic3r::Utils::SerialMessage dataCommand = {gcodeFile.substr(bytePos, bytePosEnd), Slic3r::Utils::Data}; // Break into smaller byte chunks
 
            client.enqueue_cmd(dataCommand);
 
        }
 
        res = client.run_queue();
 
        if (res)
            BOOST_LOG_TRIVIAL(info) << boost::format("[Flashforge Serial] Sent %1% ") % gcodeFile.size();
 
 
        if (!res) {
            BOOST_LOG_TRIVIAL(info) << boost::format("[Flashforge Serial] error %1%") % client.error_message().c_str();
            errormsg = wxString::FromUTF8(client.error_message().c_str());
            error_fn(std::move(errormsg));
        } else {
 
            client.set_tcp_queue_delay(std::chrono::milliseconds(3000));
 
            BOOST_LOG_TRIVIAL(info) << boost::format("[Flashforge Serial] Sending file save command ");
            
            client.enqueue_cmd(saveFileCommand);
 
            res = client.run_queue();
 
            if (upload_data.post_action == PrintHostPostUploadAction::StartPrint)
                res = start_print(errormsg, upload_filename);
        }
 
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(info) << boost::format("[Flashforge Serial] error %1%") % e.what();
        errormsg = wxString::FromUTF8(e.what());
        error_fn(std::move(errormsg));
    }
 
    return res;
}

References Slic3r::Utils::Command, connect(), Slic3r::Utils::Data, m_bufferSize, m_check_code, m_console_port, m_host, m_serial_number, Slic3r::PrintHostUpload::post_action, saveFileCommand, Slic3r::PrintHostUpload::source_path, start_print(), Slic3r::StartPrint, upload_local_api(), and Slic3r::PrintHostUpload::upload_path.

Here is the call graph for this function:

upload_local_api()

bool Slic3r::Flashforge::upload_local_api ( PrintHostUpload upload_data, ProgressFn progress_fn, ErrorFn error_fn ) const

private

{
    bool        res            = true;
    std::string material_map_b64;
    std::string material_map_json = "[]";
    auto        leveling_before_print = upload_data.extended_info["levelingBeforePrint"] == "1";
    auto        time_lapse_video      = upload_data.extended_info["timeLapseVideo"] == "1";
    auto        use_material_station  = upload_data.extended_info["useMatlStation"] == "1";
 
    if (auto it = upload_data.extended_info.find("materialMappings"); it != upload_data.extended_info.end())
        material_map_json = it->second;
 
    material_map_b64.resize(boost::beast::detail::base64::encoded_size(material_map_json.size()));
    material_map_b64.resize(boost::beast::detail::base64::encode(material_map_b64.data(), material_map_json.data(), material_map_json.size()));
 
    auto        url      = make_http_url("uploadGcode");
    const std::string fallback_extension = upload_data.source_path.extension().string().empty() ? (upload_data.use_3mf ? ".3mf" : ".gcode") : upload_data.source_path.extension().string();
    auto        filename = sanitize_flashforge_filename(upload_data.upload_path.string(), fallback_extension);
    std::string file_size;
    try {
        file_size = std::to_string(fs::file_size(upload_data.source_path));
    } catch (...) {
        file_size = "0";
    }
 
    auto http = Http::post(url);
    http.header("serialNumber", m_serial_number)
        .header("checkCode", m_check_code)
        .header("fileSize", file_size)
        .header("printNow", upload_data.post_action == PrintHostPostUploadAction::StartPrint ? "true" : "false")
        .header("levelingBeforePrint", leveling_before_print ? "true" : "false")
        .header("flowCalibration", "false")
        .header("firstLayerInspection", "false")
        .header("timeLapseVideo", time_lapse_video ? "true" : "false")
        .header("useMatlStation", use_material_station ? "true" : "false")
        .header("gcodeToolCnt", upload_data.extended_info["gcodeToolCnt"])
        .header("materialMappings", material_map_b64)
        .form_add_file("gcodeFile", upload_data.source_path.string(), filename)
        .on_complete([&](std::string body, unsigned status) {
            wxString msg;
            if (!validate_local_api_response(body, msg)) {
                BOOST_LOG_TRIVIAL(error) << boost::format("[Flashforge HTTP] upload rejected by printer: HTTP %1% body: `%2%`") % status % body;
                error_fn(msg);
                res = false;
            } else {
                BOOST_LOG_TRIVIAL(info) << boost::format("[Flashforge HTTP] upload complete: HTTP %1% body: %2%") % status % body;
            }
        })
        .on_error([&](std::string body, std::string error, unsigned status) {
            BOOST_LOG_TRIVIAL(error) << boost::format("[Flashforge HTTP] upload failed: %1%, HTTP %2%, body: `%3%`") % error % status % body;
            error_fn(format_error(body, error, status));
            res = false;
        })
        .on_progress([&](Http::Progress progress, bool& cancel) {
            progress_fn(std::move(progress), cancel);
            if (cancel)
                res = false;
        })
        .perform_sync();
 
    return res;
}

References Slic3r::PrintHostUpload::extended_info, Slic3r::PrintHost::format_error(), Slic3r::http, m_check_code, m_serial_number, make_http_url(), Slic3r::Http::post(), Slic3r::PrintHostUpload::post_action, Slic3r::PrintHostUpload::source_path, Slic3r::StartPrint, Slic3r::PrintHostUpload::upload_path, and Slic3r::PrintHostUpload::use_3mf.

Referenced by upload().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

connectKlipperCommand

Slic3r::Utils::SerialMessage Slic3r::Flashforge::connectKlipperCommand = {"~M640\r\n",Slic3r::Utils::Command}

private

{"~M640\r\n",Slic3r::Utils::Command};

Referenced by connect().

connectLegacyCommand

Slic3r::Utils::SerialMessage Slic3r::Flashforge::connectLegacyCommand = {"~M650\r\n",Slic3r::Utils::Command}

private

{"~M650\r\n",Slic3r::Utils::Command};

Referenced by connect().

controlCommand

Slic3r::Utils::SerialMessage Slic3r::Flashforge::controlCommand = {"~M601 S1\r\n",Slic3r::Utils::Command}

private

{"~M601 S1\r\n",Slic3r::Utils::Command};

Referenced by connect(), and test().

deviceInfoCommand

Slic3r::Utils::SerialMessage Slic3r::Flashforge::deviceInfoCommand = {"~M115\r\n", Slic3r::Utils::Command}

private

{"~M115\r\n", Slic3r::Utils::Command};

Referenced by connect().

m_bufferSize

const int Slic3r::Flashforge::m_bufferSize

private

Referenced by Flashforge(), and upload().

m_check_code

std::string Slic3r::Flashforge::m_check_code

private

Referenced by Flashforge(), fetch_material_slots(), get_test_failed_msg(), get_test_ok_msg(), test(), test_local_api(), upload(), and upload_local_api().

m_console_port

std::string Slic3r::Flashforge::m_console_port

private

Referenced by Flashforge(), connect(), start_print(), test(), and upload().

m_gcFlavor

GCodeFlavor Slic3r::Flashforge::m_gcFlavor

private

Referenced by Flashforge(), and connect().

m_host

std::string Slic3r::Flashforge::m_host

private

Referenced by Flashforge(), connect(), extract_host_name(), get_host(), start_print(), test(), and upload().

m_serial_number

std::string Slic3r::Flashforge::m_serial_number

private

Referenced by Flashforge(), fetch_material_slots(), get_test_failed_msg(), get_test_ok_msg(), test(), test_local_api(), upload(), and upload_local_api().

nozzlePosCommand

Slic3r::Utils::SerialMessage Slic3r::Flashforge::nozzlePosCommand = {"~M114\r\n", Slic3r::Utils::Command}

private

{"~M114\r\n", Slic3r::Utils::Command};

printStatusCommand

Slic3r::Utils::SerialMessage Slic3r::Flashforge::printStatusCommand = {"~M27\r\n", Slic3r::Utils::Command}

private

{"~M27\r\n", Slic3r::Utils::Command};

saveFileCommand

Slic3r::Utils::SerialMessage Slic3r::Flashforge::saveFileCommand = {"~M29\r\n",Slic3r::Utils::Command}

private

{"~M29\r\n",Slic3r::Utils::Command};

Referenced by upload().

statusCommand

Slic3r::Utils::SerialMessage Slic3r::Flashforge::statusCommand = {"~M119\r\n",Slic3r::Utils::Command}

private

{"~M119\r\n",Slic3r::Utils::Command};

Referenced by connect().

tempStatusCommand

Slic3r::Utils::SerialMessage Slic3r::Flashforge::tempStatusCommand = {"~M105\r\n", Slic3r::Utils::Command}

private

{"~M105\r\n", Slic3r::Utils::Command};

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/Flashforge.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/Flashforge.cpp