364 lines
13 KiB
C++
364 lines
13 KiB
C++
#include "marlin2.h"
|
|
#include "esphome/core/log.h"
|
|
|
|
namespace esphome::marlin2 {
|
|
static const char *TAG = "marlin2";
|
|
|
|
// ── Entity registration ───────────────────────────────────────────────────
|
|
|
|
#ifdef USE_SENSOR
|
|
void Marlin2::add_sensor(const std::string &name, sensor::Sensor *sens) {
|
|
sensors_.push_back({name, sens});
|
|
}
|
|
|
|
void Marlin2::publish_sensor(const std::string &key, float value) {
|
|
auto *s = find_in_(sensors_, key);
|
|
if (s != nullptr && s->get_state() != value)
|
|
s->publish_state(value);
|
|
}
|
|
#endif
|
|
|
|
#ifdef USE_TEXT_SENSOR
|
|
void Marlin2::add_text_sensor(const std::string &name, text_sensor::TextSensor *sens) {
|
|
text_sensors_.push_back({name, sens});
|
|
}
|
|
|
|
void Marlin2::publish_text_sensor(const std::string &key, const std::string &value) {
|
|
auto *s = find_in_(text_sensors_, key);
|
|
if (s != nullptr && s->get_state() != value)
|
|
s->publish_state(value);
|
|
}
|
|
#endif
|
|
|
|
#ifdef USE_SELECT
|
|
void Marlin2::add_select(const std::string &name, select::Select *sel) {
|
|
selects_.push_back({name, sel});
|
|
}
|
|
#endif
|
|
|
|
#ifdef USE_BINARY_SENSOR
|
|
void Marlin2::add_binary_sensor(const std::string &name, binary_sensor::BinarySensor *bs) {
|
|
binary_sensors_.push_back({name, bs});
|
|
}
|
|
|
|
void Marlin2::publish_binary_sensor(const std::string &key, bool value) {
|
|
auto *s = find_in_(binary_sensors_, key);
|
|
if (s != nullptr && s->state != value)
|
|
s->publish_state(value);
|
|
}
|
|
#endif
|
|
|
|
// ── Lifecycle ─────────────────────────────────────────────────────────────
|
|
|
|
void Marlin2::setup() {
|
|
marlin_output_.reserve(256);
|
|
marlin_time_.reserve(32);
|
|
|
|
write_str("\r\n\r\nM155 S10\r\n");
|
|
write_str("\r\n\r\nM117 ESP Home Connected!\r\n");
|
|
flush();
|
|
|
|
set_printer_state("IDLE");
|
|
|
|
set_interval(15000, [this]() {
|
|
if (print_progress_ != 100)
|
|
write_str("M27\r\nM31\r\n");
|
|
});
|
|
}
|
|
|
|
void Marlin2::loop() {
|
|
while (available()) {
|
|
char c = read();
|
|
if (c == '\n' || c == '\r') {
|
|
process_line();
|
|
} else {
|
|
marlin_output_ += c;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Marlin2::dump_config() {
|
|
ESP_LOGCONFIG(TAG, "Marlin2:");
|
|
this->check_uart_settings(115200);
|
|
}
|
|
|
|
// ── G-code output ─────────────────────────────────────────────────────────
|
|
|
|
void Marlin2::write(const std::string &gcode) {
|
|
ESP_LOGD(TAG, "->GCODE: %s", gcode.c_str());
|
|
write_str(("\r\n\r\n" + gcode + "\r\n").c_str());
|
|
flush();
|
|
}
|
|
|
|
// ── Line parsing ──────────────────────────────────────────────────────────
|
|
|
|
void Marlin2::process_line() {
|
|
if (marlin_output_.size() < 3) {
|
|
marlin_output_ = "";
|
|
return;
|
|
}
|
|
|
|
if (marlin_output_.compare("ok") == 0 || marlin_output_.compare(" ok") == 0) {
|
|
listing_file_ = false;
|
|
marlin_output_ = "";
|
|
return;
|
|
}
|
|
|
|
ESP_LOGD(TAG, "DEBUG>#%s#", marlin_output_.c_str());
|
|
|
|
if (!listing_file_ && marlin_output_.compare("Begin file list") == 0) {
|
|
ESP_LOGD(TAG, "Listing of files started!");
|
|
listing_file_ = true;
|
|
file_table_.clear();
|
|
marlin_output_ = "";
|
|
return;
|
|
}
|
|
|
|
if (listing_file_ && marlin_output_.compare("End file list") == 0) {
|
|
ESP_LOGD(TAG, "Listing of files stopped!");
|
|
listing_file_ = false;
|
|
publish_sd_files();
|
|
#ifdef USE_BINARY_SENSOR
|
|
publish_binary_sensor("sd_card_present", true);
|
|
#endif
|
|
#ifdef USE_SENSOR
|
|
publish_sensor("sd_card_file_count", static_cast<float>(file_table_.size()));
|
|
#endif
|
|
marlin_output_ = "";
|
|
return;
|
|
}
|
|
|
|
if (listing_file_ && marlin_output_.find(".GCO ") > 1) {
|
|
size_t first_space = marlin_output_.find(' ');
|
|
size_t second_space = marlin_output_.find(' ', first_space + 1);
|
|
|
|
if (first_space != std::string::npos) {
|
|
std::string short_name = marlin_output_.substr(0, first_space);
|
|
|
|
if (short_name.find("/") != std::string::npos) {
|
|
ESP_LOGD(TAG, "Skipping subdirectory: %s", short_name.c_str());
|
|
marlin_output_ = "";
|
|
return;
|
|
}
|
|
|
|
std::string long_name = (second_space != std::string::npos && second_space > first_space)
|
|
? marlin_output_.substr(second_space + 1)
|
|
: short_name;
|
|
|
|
file_table_[long_name] = short_name;
|
|
}
|
|
|
|
marlin_output_ = "";
|
|
return;
|
|
}
|
|
|
|
// Temperature report: T:xx/xx B:xx/xx
|
|
if (
|
|
marlin_output_.find(" T:") == 0 ||
|
|
marlin_output_.find("T:") == 0 ||
|
|
marlin_output_.find("ok T:") == 0 ||
|
|
marlin_output_.find(" ok T:") == 0
|
|
) {
|
|
float ext_temp, ext_set, bed_temp, bed_set;
|
|
if (process_temp_msg(&ext_temp, &ext_set, &bed_temp, &bed_set) != 0) {
|
|
#ifdef USE_SENSOR
|
|
publish_sensor("bed_temperature", bed_temp);
|
|
publish_sensor("bed_set_temperature", bed_set);
|
|
publish_sensor("ext_temperature", ext_temp);
|
|
publish_sensor("ext_set_temperature", ext_set);
|
|
#endif
|
|
#ifdef USE_TEXT_SENSOR
|
|
if (bed_set == 0.0f && ext_set == 0.0f) {
|
|
if (ext_temp < 32.0f && bed_temp < 32.0f)
|
|
set_printer_state("IDLE");
|
|
else if (ext_temp < 150.0f && bed_temp < 55.0f)
|
|
set_printer_state("COOLING");
|
|
}
|
|
if (print_progress_ == 0.0f && (bed_set != 0.0f || ext_set != 0.0f))
|
|
set_printer_state("PREHEATING");
|
|
#endif
|
|
}
|
|
marlin_output_ = "";
|
|
return;
|
|
}
|
|
|
|
// Print progress: SD printing byte X/Y
|
|
if (marlin_output_.find("SD printing byte") == 0) {
|
|
print_progress_ = process_progress_msg();
|
|
#ifdef USE_SENSOR
|
|
publish_sensor("print_progress", print_progress_);
|
|
#endif
|
|
set_printer_state("PRINTING");
|
|
marlin_output_ = "";
|
|
return;
|
|
}
|
|
|
|
// Print time: echo:Print time: Xh Xm Xs
|
|
if (marlin_output_.find("echo:Print time: ") == 0) {
|
|
double current = 0, remaining = 0;
|
|
if (process_print_time_msg(¤t, &remaining, print_progress_) != 0) {
|
|
#ifdef USE_SENSOR
|
|
publish_sensor("print_time", static_cast<float>(current));
|
|
publish_sensor("print_time_remaining", static_cast<float>(remaining));
|
|
#endif
|
|
}
|
|
marlin_output_ = "";
|
|
return;
|
|
}
|
|
|
|
// File opened: SALMA_~2.GCO Size: 12279971
|
|
if (marlin_output_.find("File opened: ") == 0) {
|
|
size_t start_pos = std::strlen("File opened: ");
|
|
size_t size_pos = marlin_output_.find(" Size: ");
|
|
if (size_pos != std::string::npos) {
|
|
std::string filename = from_dos_name(marlin_output_.substr(start_pos, size_pos - start_pos));
|
|
ESP_LOGD(TAG, "File: %s", filename.c_str());
|
|
#ifdef USE_TEXT_SENSOR
|
|
publish_text_sensor("sd_card_file_selected", filename);
|
|
#endif
|
|
}
|
|
marlin_output_ = "";
|
|
return;
|
|
}
|
|
|
|
if (marlin_output_.compare("File selected") == 0) {
|
|
set_printer_state("PRINTING");
|
|
marlin_output_ = "";
|
|
return;
|
|
}
|
|
|
|
if (marlin_output_.compare("Done printing") == 0) {
|
|
print_progress_ = 100;
|
|
#ifdef USE_SENSOR
|
|
publish_sensor("print_progress", 100.0f);
|
|
publish_sensor("print_time_remaining", 0.0f);
|
|
#endif
|
|
set_printer_state("FINISHED");
|
|
marlin_output_ = "";
|
|
return;
|
|
}
|
|
|
|
if (marlin_output_.compare("Print Aborted") == 0) {
|
|
set_printer_state("STOPPED");
|
|
marlin_output_ = "";
|
|
return;
|
|
}
|
|
|
|
ESP_LOGD(TAG, ">#%s#", marlin_output_.c_str());
|
|
marlin_output_ = "";
|
|
}
|
|
|
|
// ── SD card file list ─────────────────────────────────────────────────────
|
|
|
|
void Marlin2::publish_sd_files() {
|
|
std::string chunk;
|
|
uint8_t count = 0;
|
|
#ifdef USE_SELECT
|
|
std::vector<std::string> file_names;
|
|
#endif
|
|
|
|
for (const auto &[key, value] : file_table_) {
|
|
if (count >= max_sd_files_) {
|
|
ESP_LOGW(TAG, "SD file list truncated to %u files (total: %u)",
|
|
max_sd_files_, (unsigned) file_table_.size());
|
|
break;
|
|
}
|
|
if (!chunk.empty()) chunk += "|";
|
|
chunk += key;
|
|
#ifdef USE_SELECT
|
|
file_names.push_back(key);
|
|
#endif
|
|
count++;
|
|
}
|
|
|
|
#ifdef USE_TEXT_SENSOR
|
|
publish_text_sensor("sd_card_files", chunk);
|
|
#endif
|
|
#ifdef USE_SELECT
|
|
auto *sel = find_in_(selects_, std::string("sd_card_file_select"));
|
|
if (sel != nullptr)
|
|
sel->traits.set_options(file_names);
|
|
#endif
|
|
}
|
|
|
|
// ── Message parsers ───────────────────────────────────────────────────────
|
|
|
|
int Marlin2::process_temp_msg(float *ext_temperature, float *ext_set_temperature, float *bed_temperature, float *bed_set_temperature) {
|
|
float dc;
|
|
|
|
while (marlin_output_.find(" ") != std::string::npos)
|
|
marlin_output_.erase(marlin_output_.find(' '), 1);
|
|
while (marlin_output_.find("ok") != std::string::npos)
|
|
marlin_output_.erase(marlin_output_.find("ok"), 2);
|
|
|
|
if (sscanf(marlin_output_.c_str(), "T:%f/%fB:%f/%f", ext_temperature, ext_set_temperature, bed_temperature, bed_set_temperature) == 4)
|
|
return 1;
|
|
if (sscanf(marlin_output_.c_str(), "T:%f/%f(%f)B:%f/%f(%f)", ext_temperature, ext_set_temperature, &dc, bed_temperature, bed_set_temperature, &dc) == 6)
|
|
return 2;
|
|
if (sscanf(marlin_output_.c_str(), "T:%f/%fT0:%f/%fT1:%f/%fB:%f/%f", ext_temperature, ext_set_temperature, &dc, &dc, &dc, &dc, bed_temperature, bed_set_temperature) == 8)
|
|
return 3;
|
|
if (sscanf(marlin_output_.c_str(), "T0:%f/%fT1:%f/%fB:%f/%f", ext_temperature, ext_set_temperature, &dc, &dc, bed_temperature, bed_set_temperature) == 6)
|
|
return 4;
|
|
|
|
return 0;
|
|
}
|
|
|
|
float Marlin2::process_progress_msg() {
|
|
size_t slash_pos = marlin_output_.find('/');
|
|
if (slash_pos == std::string::npos || slash_pos + 1 >= marlin_output_.size())
|
|
return 0.0f;
|
|
|
|
float current = std::stof(marlin_output_.substr(17));
|
|
float total = std::stof(marlin_output_.substr(slash_pos + 1));
|
|
|
|
if (total < 1.0f)
|
|
return 0.0f;
|
|
|
|
return roundf((current * 100.0f) / total);
|
|
}
|
|
|
|
int Marlin2::process_print_time_msg(double *current, double *remaining, float progress) {
|
|
marlin_time_ = marlin_output_.substr(16);
|
|
float d = 0, h = 0, m = 0, s = 0;
|
|
|
|
if (sscanf(marlin_time_.c_str(), "%fd %fh %fm %fs", &d, &h, &m, &s) != 4) {
|
|
d = 0;
|
|
if (sscanf(marlin_time_.c_str(), "%fh %fm %fs", &h, &m, &s) != 3) {
|
|
h = 0;
|
|
if (sscanf(marlin_time_.c_str(), "%fm %fs", &m, &s) != 2) {
|
|
m = 0;
|
|
if (sscanf(marlin_time_.c_str(), "%fs", &s) != 1)
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
*current = round((d * 24 * 60 * 60) + (h * 60 * 60) + (m * 60) + s);
|
|
|
|
if (progress != 0.0f && progress != 100.0f)
|
|
*remaining = ((100.0 * *current) / round(progress)) - *current;
|
|
|
|
return 1;
|
|
}
|
|
|
|
void Marlin2::set_printer_state(const std::string &status) {
|
|
#ifdef USE_TEXT_SENSOR
|
|
publish_text_sensor("printer_state", status);
|
|
#endif
|
|
}
|
|
|
|
// ── Filename mapping ──────────────────────────────────────────────────────
|
|
|
|
std::string Marlin2::to_dos_name(const std::string &filename) {
|
|
auto it = file_table_.find(filename);
|
|
return (it != file_table_.end()) ? it->second : filename;
|
|
}
|
|
|
|
std::string Marlin2::from_dos_name(const std::string &dos_filename) {
|
|
for (const auto &[key, value] : file_table_)
|
|
if (value == dos_filename) return key;
|
|
return dos_filename;
|
|
}
|
|
|
|
} // namespace esphome::marlin2
|