【3d打印】基于Klipper的3d打印远程上位机系统(Qt)，klipper源码，通信解析，打印参数设置

最新推荐文章于 2025-04-03 16:49:51 发布

rqtz

最新推荐文章于 2025-04-03 16:49:51 发布

阅读量1k

点赞数 18

文章标签： python pyqt 3d打印

本文链接：https://blog.youkuaiyun.com/m0_75192474/article/details/145903328

版权

3d打印远程上位机系统介绍

此上位机是基于3d打印固件Klipper，使用pyqt+tcp协议，Klipper 是一款开源的 3D 打印机固件，其中Klipper提供了可以与外部通信的API，通过借助这些API,可以开发一个远程的3d打印系统，该系统可以控制x,y,z三轴任意距离的移动，风扇调速，轴速控制，摄像头画面获取和部分G代码命令。

klipper有提供技术文档概述 - Klipper 文档

githup开源地址https://github.com/Klipper3d/klipper

如果本文对你有所帮助，那能否支持一下老弟呢，嘻嘻🥰

✨✨个人主页点击✨✨

klipper通信框架分析

🤠Klipper的网页端主要有以下几种

Mainsail：一个开源项目，主要使用 Vue.js 和 TypeScript 编程语言，旨在为使用 Klipper 固件的 3D 打印机提供流行的网页界面。具有响应式网页界面，可优化用于桌面、平板和移动设备；支持管理多台 3D 打印机；支持 12 种不同语言等众多功能。
Fluidd：也是一款免费、开源的 Klipper 网页界面，同样使用 Vue.js 等技术开发，用于管理 3D 打印机。提供响应式的用户界面，支持桌面、平板和移动设备，内置多种颜色主题，可从一个 Fluidd 安装中管理多个打印机，还能让用户根据喜好移动任何面板，实现个性化的界面布局。
Octoprint：它原本不完全算是专门为 Klipper 打造的网页界面，但也能与 Klipper 配合使用。有大量插件资源，适合已经习惯使用 Octoprint 且有较多插件依赖，或是追求功能全面、稳定可靠界面的用户。

🕵🏼就Fluidd而言，通信流程是Fluidd通过HTTP/Websocket协议连接运行在Klipper主机的web服务器Moonraker连接，moonraker再通过本地UNIX套接字与Klipper主机通信。

上述是浏览器通信，也就是HTTP协议的。

Klipper通信源码分析

Moonraker是一个用于外界客户端与Klipper主机通信的web服务器接口

Moonraker开源地址GitHub - Arksine/moonraker: Web API Server for Klipper

在klipper的源码路径为

/klipper-master/scripts/whconsole.py

whconsole.py中实现了如何通过本地UNIX套接字与Klipper通信

#!/usr/bin/env python2
# Test console for webhooks interface
#
# Copyright (C) 2020  Kevin O'Connor <kevin@koconnor.net>
#
# This file may be distributed under the terms of the GNU GPLv3 license.
import sys, os, optparse, socket, fcntl, select, json, errno, time

# Set a file-descriptor as non-blocking
def set_nonblock(fd):
    fcntl.fcntl(fd, fcntl.F_SETFL
                , fcntl.fcntl(fd, fcntl.F_GETFL) | os.O_NONBLOCK)

def webhook_socket_create(uds_filename):
    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
    sock.setblocking(0)
    sys.stderr.write("Waiting for connect to %s\n" % (uds_filename,))
    while 1:
        try:
            sock.connect(uds_filename)
        except socket.error as e:
            if e.errno == errno.ECONNREFUSED:
                time.sleep(0.1)
                continue
            sys.stderr.write("Unable to connect socket %s [%d,%s]\n"
                             % (uds_filename, e.errno,
                                errno.errorcode[e.errno]))
            sys.exit(-1)
        break
    sys.stderr.write("Connection.\n")
    return sock

class KeyboardReader:
    def __init__(self, uds_filename):
        self.kbd_fd = sys.stdin.fileno()
        set_nonblock(self.kbd_fd)
        self.webhook_socket = webhook_socket_create(uds_filename)
        self.poll = select.poll()
        self.poll.register(sys.stdin, select.POLLIN | select.POLLHUP)
        self.poll.register(self.webhook_socket, select.POLLIN | select.POLLHUP)
        self.kbd_data = self.socket_data = b""
    def process_socket(self):
        data = self.webhook_socket.recv(4096)
        if not data:
            sys.stderr.write("Socket closed\n")
            sys.exit(0)
        parts = data.split(b'\x03')
        parts[0] = self.socket_data + parts[0]
        self.socket_data = parts.pop()
        for line in parts:
            sys.stdout.write("GOT: %s\n" % (line,))
    def process_kbd(self):
        data = os.read(self.kbd_fd, 4096)
        parts = data.split(b'\n')
        parts[0] = self.kbd_data + parts[0]
        self.kbd_data = parts.pop()
        for line in parts:
            line = line.strip()
            if not line or line.startswith(b'#'):
                continue
            try:
                m = json.loads(line)
            except:
                sys.stderr.write("ERROR: Unable to parse line\n")
                continue
            cm = json.dumps(m, separators=(',', ':'))
            sys.stdout.write("SEND: %s\n" % (cm,))
            self.webhook_socket.send(cm.encode() + b"\x03")
    def run(self):
        while 1:
            res = self.poll.poll(1000.)
            for fd, event in res:
                if fd == self.kbd_fd:
                    self.process_kbd()
                else:
                    self.process_socket()

def main():
    usage = "%prog [options] <socket filename>"
    opts = optparse.OptionParser(usage)
    options, args = opts.parse_args()
    if len(args) != 1:
        opts.error("Incorrect number of arguments")

    ml = KeyboardReader(args[0])
    ml.run()

if __name__ == '__main__':
    main()

🧐函数解析：

main()函数：

前半段是用optparse库来进行接收命令行参数，该参数是用于UNIX套接字通信的文件，以.sock结尾，它是一种特殊类型的文件，用于在同一台计算机上的不同进程之间进行通信
ml = KeyboardReader(args[0])
    ml.run()
后半段是KeyboardReader类初始化并运行run()函数。

KeyboardReader类初始化：

在__init__函数中有这样一行代码
self.webhook_socket = webhook_socket_create(uds_filename)
这是用于连接本地UNIX套接字的函数，其中uds_filename是传过来的UNIX套接字文件

webhook_socket_create()函数：
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
这行代码用于创建一个 UNIX 域流式套接字对象

下面的while循环指的是与套接字来接，成功后返回一个用于通信的套接字对象sock。

到此KeyboardReader初始化完成。

run()函数：

其中self.process_kbd()是用于通信和解析JSON数据的函数

Klipper通信API协议分析

🌴klipper通信的协议是以“{JSON格式}”的数据,在Python中称为“字典”，且请求字典中必须包含一个”method”字段，其值应包含一个可用的Klipper端点”endpoint”名称字符串。

可用的endpoint有（部分）详细可看官方文档

info：

“info” 用于从Klipper获取系统和版本信息。同时也被用来向Klipper提供客户端的版本信息。比如说

{"id": 123, "method": "info", "params": { "client_info": { "version": "v1"}}}

如果存在，“client_info”参数必须是一个字典，但该字典可能具有任意内容。鼓励客户端在首次连接到Klipper API服务器时提供客户端名称及其软件版本。

gcode/script：

这个endpoint允许运行一系列的G代码命令。比如说：

{"id": 123, "method": "gcode/script", "params": {"script": "G90"}}

emergency_stop：

"emergency_stop"端点用于指示 Klipper 过渡到 "shutdown"状态。它的行为类似于 G 代码 "M112 "命令。例如：

{"id"： 123, "method"： "emergency_stop"}

objects/list

该端点查询可用打印机“对象”的列表，可以查询（通过“对象/查询”端点）。例如：

｛“id”：123，“method”：“objects/list”｝

可能返回：

{"id": 123, "result": {"objects": ["webhooks", "configfile", "heaters", "gcode_move", "query_endstops", "idle_timeout", "toolhead", "extruder"]}}

objects/query

这个endpoint允许从打印机对象中查询信息。比如说：

{"id": 123, "method": "objects/query", "params": {"objects": {"toolhead": ["position"], "webhooks": null}}}

可能返回

{"id": 123, "result": {"status": {"webhooks": {"state": "ready", "state_message": "Printer is ready"}, "toolhead": {"position": [0.0, 0.0, 0.0, 0.0]}}, "eventtime": 3051555.377933684}}

使用TCP协议搭建应用程序/服务器与Klipper通信

🔥通过上述的解释之后，我们知道了klipper的通信流程，我们可以使用tcp协议的客户端应用程序与moonraker通信，当然如果你不想使用moonraker服务器，你同样可以自己写一个服务器，如果只是功能实现的话，理论上来讲是比较容易的，因为前面说的已经很清楚了，本质就是UNIX+TCP通信。

下面就是一个简单的UNIX与TCP的服务器程序

import socket
import errno
import time
import sys
import json
from optparse import OptionParser
class server:
    #函数初始化
    def __init__(self):
        self.uds_filename = "/home/biqu/printer_data/comms/klippy.sock"
        parser = OptionParser()
        parser.add_option("-i", "--ip", dest="ip",
                        help="setting ip address for server",default="192.168.1.235")
        parser.add_option("-p", "--port", dest="port",
                        help="setting ip address for server", default=8899)

        (options, args) = parser.parse_args()

        if options.ip:         
            self.ip = options.ip
        if options.port:         
            self.port = options.port
        # print(self.ip,self.port)
        self.unixsocket = self.connect_unixserver(self.uds_filename)
        self.connect_tcpserver()
    #连接tcp服务器
    def connect_tcpserver(self):
        self.tcpser = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        # ip = input("请输入ip地址")
        self.tcpser.bind((self.ip,self.port))
        self.tcpser.listen(1)
        print("tcp server listening......")
        self.tcpsocket,addr = self.tcpser.accept()
        print("tcp server connect client successly",addr)
        while 1:
            bytedata = self.tcpsocket.recv(4096)
            if  bytedata:
                self.srtdata = bytedata.decode(encoding="utf-8")
                print(self.srtdata)
                self.process_kbd(self.srtdata)
            if not bytedata:
                print("server disconnect")
                break
        self.tcpser.close()
        self.unixsocket.close()
    #连接UNIX套接字
    def connect_unixserver(self,uds_filename):
        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
        print("unix server is connecting ......")
        sock.setblocking(0)
        while 1:
            try:
                sock.connect(uds_filename)
            except socket.error as e:
                if e.errno == errno.ECONNREFUSED:
                    time.sleep(0.1)
                    continue
                print("donot connect unix server %s [%d,%s]\n"
                                % (uds_filename, e.errno,
                                    errno.errorcode[e.errno]))
                sys.exit(-1)
            break
        print("unix server connect client successly.")
        return sock
    #将tcp份客户端的数据通过UNIX套接字传回klipper中
    def process_kbd(self,gcode):
        parts = gcode.split('\n')
        for line in parts:
            line = line.strip()
            if not line or line.startswith('#'):
                continue
            try:
                m = json.loads(line)
            except:
                sys.stderr.write("ERROR: Unable to parse line\n")
                continue
            cm = json.dumps(m, separators=(',', ':'))
            # self.unixsocket.send("%s\x03" % (cm))
            self.unixsocket.send(cm.encode()+b"\x03")

if __name__ == '__main__':
    ser = server()

其中UNIX套接字文件选择你klipper主机的printer_data目录下的.sock文件

self.uds_filename = "/home/xxx/printer_data/comms/klippy.sock"

IP和端口选择你运行klipper主机的ip地址和端口

运行

python2 server.py -i 192.168.242.34 -p 8899

注意最好用python2运行，python3运行会有问题。

⚡而客户端只要按照服务器的IP和端口进行连接就可以了

如下

 def connect_server(self):
        self.client_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        self.client_socket.connect(192.168.242.34,8899)
        self.app.serveredit.setText("tcp服务器连接成功......")

接下来只要按照klipper官方的通信协议发送就可以远程控制打印机了