progress

.gitignore

@@ -0,0 +1,2 @@
+s
+__pycache__/*

README.md

@@ -8,6 +8,15 @@ A configured uart is required.
 
 Example:
 ```yaml
+api:
+  actions:
+    - action: 'set_bed_temperature'
+      variables:
+        temperature: int
+      then:
+        - marlin2.write_g_code
+            gcode: !lampda "return temperature"
+  ...
   
 marlin2:
   uart_id: uart_bus

__init__.py

@@ -16,15 +16,18 @@ from esphome.const import (
     DEVICE_CLASS_TEMPERATURE,
     DEVICE_CLASS_DURATION,
     CONF_DATA,
+    CONF_VALUE
 )
 from esphome import pins, automation
+from esphome.core import CORE, coroutine_with_priority
 
 CODEOWNERS = ["@jonatanrek"]
 DEPENDENCIES = ['uart']
 CONF_MARLIN2_ID = "marlin2_id"
 
 Marlin2 = cg.esphome_ns.class_('Marlin2', cg.Component)
-Marlin2WriteAction = Marlin2.class_("Marlin2WriteAction", automation.Action)
+WriteAction = cg.esphome_ns.class_("WriteAction", automation.Action)
+PrintFileAction = cg.esphome_ns.class_("PrintFileAction", automation.Action)
 
 CONFIG_SCHEMA = cv.All(
     cv.Schema({
@@ -43,19 +46,43 @@ def validate_raw_data(value):
         return cv.Schema([cv.hex_uint8_t])(value)
     raise cv.Invalid("data must either be a string wrapped in quotes or a list of bytes")
 
-@automation.register_action(
-    "marlin2.write",
-    Marlin2WriteAction,
-    cv.maybe_simple_value(
-        {
-            cv.GenerateID(): cv.declare_id(Marlin2),
-            cv.Required(CONF_DATA): cv.templatable(validate_raw_data),
-        },
-        key=CONF_DATA,
-    ),
-)
-
+@coroutine_with_priority(100.0)
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     await uart.register_uart_device(var, config)
+
+OPERATION_BASE_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.use_id(Marlin2),
+    cv.Required(CONF_VALUE): cv.templatable(cv.string_strict),
+})
+
+OPERATION_BASE_SCHEMA_2 = cv.Schema({
+    cv.GenerateID(): cv.use_id(Marlin2),
+    cv.Required(CONF_VALUE): cv.templatable(cv.string_strict),
+})
+
+@automation.register_action(
+    "marlin2.write",
+    WriteAction,
+    OPERATION_BASE_SCHEMA,
+)
+
+async def marlin2_write_to_code(config, action_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+    template_ = await cg.templatable(config[CONF_VALUE], args, cg.std_string)
+    cg.add(var.set_value(template_))
+    return var
+
+@automation.register_action(
+    "marlin2.print_file",
+    PrintFileAction,
+    OPERATION_BASE_SCHEMA_2,
+)
+async def marlin2_print_file_to_code(config, action_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+    template_ = await cg.templatable(config[CONF_VALUE], args, cg.std_string)
+    cg.add(var.set_value(template_))
+    return var

automation.h

@@ -1,36 +1,38 @@
 #pragma once
 
-#include "marlin2.h"
 #include "esphome/core/automation.h"
-
-#include <vector>
+#include "esphome/core/component.h"
+#include "marlin2.h"
 
 namespace esphome {
+    static const char *TAG = "marlin2";
 
-template<typename... Ts> class Marlin2WriteAction : public Action<Ts...>, public Parented<Marlin2> {
+    template<typename... Ts> class WriteAction : public Action<Ts...> {
         public:
-        void set_data_template(std::function<std::vector<uint8_t>(Ts...)> func) {
-            this->data_func_ = func;
-            this->static_ = false;
-        }
-        void set_data_static(const std::vector<uint8_t> &data) {  
-            this->data_static_ = data;
-            this->static_ = true;
-        }
+            explicit WriteAction(Marlin2 *marlin2) : marlin2_(marlin2) {}
+            TEMPLATABLE_VALUE(std::string, value)
 
             void play(Ts... x) override {
-            if (this->static_) {
-                this->parent_->write_array(this->data_static_);
-            } else {
-                auto val = this->data_func_(x...);
-                this->parent_->write_array(val);
-            }
+                this->marlin2_->write(this->value_.value(x...));
             }
 
         protected:
-        bool static_{false};
-        std::function<std::vector<uint8_t>(Ts...)> data_func_{};
-        std::vector<uint8_t> data_static_{};
+            Marlin2 *marlin2_;
     };
 
+
+    template<typename... Ts> class PrintFileAction : public Action<Ts...> {
+        public:
+            explicit PrintFileAction(Marlin2 *marlin2) : marlin2_(marlin2) {}
+            TEMPLATABLE_VALUE(std::string, value)
+
+            void play(Ts... x) override {
+                std::string file_name = this->marlin2_->to_dos_name(this->value_.value(x...));
+                ESP_LOGD(TAG, "->FILE: %s", file_name.c_str());
+                this->marlin2_->write(str_sprintf("M32 P !%s#", file_name.c_str()));
+            }
+
+        protected:
+            Marlin2 *marlin2_;
+    };
 }  // namespace esphome

marlin2.cpp

@@ -33,11 +33,13 @@ namespace esphome {
     }
     #endif
     
-
     void Marlin2::setup() {
         MarlinOutput.reserve(256);
         MarlinOutput = "";
         
+        MarlinResponseOutput.reserve(256);
+        MarlinResponseOutput = "";
+        
         MarlinTime.reserve(32);
         PrinterState.reserve(32);
         
@@ -50,16 +52,17 @@ namespace esphome {
         set_printer_state("IDLE");
     }
     
-void Marlin2::set_bed_setpoint() {
-
+    void Marlin2::write(std::string gcode) {
+        ESP_LOGD(TAG, "->GCODE: %s", gcode.c_str());
+        write_str((std::string("\r\n\r\n") + gcode + std::string("\r\n")).c_str());
+        flush();
     }
-void Marlin2::set_extruder_setpoint() {
     
-}
     void Marlin2::update() {
         while (available()) {
             char c = read();
             if( c == '\n' || c == '\r' ) {
+                ESP_LOGD(TAG, "#%s#",MarlinOutput.c_str());    
                 process_line();
             } else {
                 MarlinOutput += c;
@@ -83,10 +86,43 @@ void Marlin2::set_extruder_setpoint() {
         }
         
         if(!MarlinOutput.compare("ok") || !MarlinOutput.compare(" ok")) {
+            listingFile = false;
             MarlinOutput="";
             return;
         }
         
+        if(!listingFile && MarlinOutput.compare("Begin file list") == 0) {
+            ESP_LOGD(TAG, "Listing of files started!");
+            listingFile = true;
+            //reset string for next line
+            MarlinOutput="";
+            return;
+        }
+        
+        if(listingFile && MarlinOutput.compare(".GCO ")) {                            
+            int first_space = MarlinOutput.find(' ');
+            int second_space = MarlinOutput.find(' ', first_space + 1);
+            
+            if(first_space > 0) {                
+                std::string short_name = MarlinOutput.substr(0, first_space);
+                std::string long_name = short_name;
+
+                if (second_space > first_space){
+                    long_name = MarlinOutput.substr(second_space + 1);
+                }
+                
+                file_table_[long_name] = short_name;
+                ESP_LOGD(TAG, "Uloženo do tabulky: %s => %s", long_name.c_str(), short_name.c_str());
+                
+            }
+            
+            //reset string for next line
+            MarlinOutput="";
+            return;
+        }
+        
+        
+        
         //Parse periodic Temperature read out message
         if(
             MarlinOutput.find(" T:")    == 0 ||
@@ -215,6 +251,17 @@ void Marlin2::set_extruder_setpoint() {
             return;
         }
         
+        
+        
+        if(MarlinOutput.find("End file list") != std::string::npos) {                
+            ESP_LOGD(TAG, "Listing of files stopped!");
+            listingFile = false;
+            //reset string for next line
+            MarlinOutput="";
+            return;
+        }
+        
+        
         ESP_LOGD(TAG, "#%s#",MarlinOutput.c_str());        
         MarlinOutput="";
         return;
@@ -297,4 +344,34 @@ void Marlin2::set_extruder_setpoint() {
         #endif
     }
     
+    std::string Marlin2::to_dos_name(std::string filename) {
+        std::string shortName;
+        size_t dotPos = filename.find_last_of('.');
+        
+        // Extract name and extension
+        std::string namePart = (dotPos != std::string::npos) ? filename.substr(0, dotPos) : filename;
+        std::string extPart = (dotPos != std::string::npos) ? filename.substr(dotPos + 1) : "";
+        
+        // Truncate name to 6 characters + ~1
+        if (namePart.length() > 6) {
+            namePart = namePart.substr(0, 6) + "~1";
+        }
+        
+        // Truncate extension to 3 characters
+        if (extPart.length() > 3) {
+            extPart = extPart.substr(0, 3);
+        }
+        
+        // Construct 8.3 filename
+        shortName = namePart;
+        if (!extPart.empty()) {
+            shortName += "." + extPart;
+        }
+        
+        // Convert to uppercase (DOS filenames are case-insensitive, usually stored in uppercase)
+        std::transform(shortName.begin(), shortName.end(), shortName.begin(), ::toupper);
+        
+        return shortName;
+    }
+    
 }  // namespace esphome

marlin2.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <string>
+#include <unordered_map>
 #include "esphome/core/component.h"
 #include "esphome/components/uart/uart.h"
 #ifdef USE_SENSOR
@@ -15,7 +17,6 @@ class Marlin2 : public PollingComponent, public uart::UARTDevice {
     public:
         Marlin2() = default;
 
-
         #ifdef USE_SENSOR
             void add_sensor(const std::string& sName, sensor::Sensor *sens);
             sensor::Sensor* find_sensor(std::string key);
@@ -24,8 +25,8 @@ class Marlin2 : public PollingComponent, public uart::UARTDevice {
             void add_text_sensor(const std::string& sName, text_sensor::TextSensor *tSens);
             text_sensor::TextSensor* find_text_sensor(std::string key);
         #endif
-        void set_bed_setpoint();
-        void set_extruder_setpoint();
+        void write(std::string status);
+        std::string to_dos_name(std::string file_name);
 
         float get_setup_priority() const override { return setup_priority::LATE; }
         void setup() override;
@@ -33,13 +34,13 @@ class Marlin2 : public PollingComponent, public uart::UARTDevice {
 
     protected:
         std::string MarlinOutput;
+        std::string MarlinResponseOutput;
         std::string MarlinTime;
         std::string PrinterState;
 
         float print_progress = 0;
         double print_time_offset = 0;
         
-        
         #ifdef USE_SENSOR
             std::vector<std::pair<std::string, sensor::Sensor *>> sensors;
         #endif
@@ -55,6 +56,8 @@ class Marlin2 : public PollingComponent, public uart::UARTDevice {
 
     private:
         unsigned long millisProgress=0;
+        std::unordered_map<std::string, std::string> file_table_;
+        bool listingFile = false;
 };
 
 }  // namespace esphome