Add hannoprint code
This commit is contained in:
m
@@ -0,0 +1,447 @@
|
||||
#
|
||||
# MarlinBinaryProtocol.py
|
||||
# Supporting Firmware upload via USB/Serial, saving to the attached media.
|
||||
#
|
||||
import serial
|
||||
import math
|
||||
import time
|
||||
from collections import deque
|
||||
import threading
|
||||
import sys
|
||||
import datetime
|
||||
import random
|
||||
try:
|
||||
import heatshrink
|
||||
heatshrink_exists = True
|
||||
except ImportError:
|
||||
heatshrink_exists = False
|
||||
|
||||
|
||||
def millis():
|
||||
return time.perf_counter() * 1000
|
||||
|
||||
class TimeOut(object):
|
||||
def __init__(self, milliseconds):
|
||||
self.duration = milliseconds
|
||||
self.reset()
|
||||
|
||||
def reset(self):
|
||||
self.endtime = millis() + self.duration
|
||||
|
||||
def timedout(self):
|
||||
return millis() > self.endtime
|
||||
|
||||
class ReadTimeout(Exception):
|
||||
pass
|
||||
class FatalError(Exception):
|
||||
pass
|
||||
class SycronisationError(Exception):
|
||||
pass
|
||||
class PayloadOverflow(Exception):
|
||||
pass
|
||||
class ConnectionLost(Exception):
|
||||
pass
|
||||
|
||||
class Protocol(object):
|
||||
device = None
|
||||
baud = None
|
||||
max_block_size = 0
|
||||
port = None
|
||||
block_size = 0
|
||||
|
||||
packet_transit = None
|
||||
packet_status = None
|
||||
packet_ping = None
|
||||
|
||||
errors = 0
|
||||
packet_buffer = None
|
||||
simulate_errors = 0
|
||||
sync = 0
|
||||
connected = False
|
||||
syncronised = False
|
||||
worker_thread = None
|
||||
|
||||
response_timeout = 1000
|
||||
|
||||
applications = []
|
||||
responses = deque()
|
||||
|
||||
def __init__(self, device, baud, bsize, simerr, timeout):
|
||||
print("pySerial Version:", serial.VERSION)
|
||||
self.port = serial.Serial(device, baudrate = baud, write_timeout = 0, timeout = 1)
|
||||
self.device = device
|
||||
self.baud = baud
|
||||
self.block_size = int(bsize)
|
||||
self.simulate_errors = max(min(simerr, 1.0), 0.0);
|
||||
self.connected = True
|
||||
self.response_timeout = timeout
|
||||
|
||||
self.register(['ok', 'rs', 'ss', 'fe'], self.process_input)
|
||||
|
||||
self.worker_thread = threading.Thread(target=Protocol.receive_worker, args=(self,))
|
||||
self.worker_thread.start()
|
||||
|
||||
def receive_worker(self):
|
||||
while self.port.in_waiting:
|
||||
self.port.reset_input_buffer()
|
||||
|
||||
def dispatch(data):
|
||||
for tokens, callback in self.applications:
|
||||
for token in tokens:
|
||||
if token == data[:len(token)]:
|
||||
callback((token, data[len(token):]))
|
||||
return
|
||||
|
||||
def reconnect():
|
||||
print("Reconnecting..")
|
||||
self.port.close()
|
||||
for x in range(10):
|
||||
try:
|
||||
if self.connected:
|
||||
self.port = serial.Serial(self.device, baudrate = self.baud, write_timeout = 0, timeout = 1)
|
||||
return
|
||||
else:
|
||||
print("Connection closed")
|
||||
return
|
||||
except:
|
||||
time.sleep(1)
|
||||
raise ConnectionLost()
|
||||
|
||||
while self.connected:
|
||||
try:
|
||||
data = self.port.readline().decode('utf8').rstrip()
|
||||
if len(data):
|
||||
#print(data)
|
||||
dispatch(data)
|
||||
except OSError:
|
||||
reconnect()
|
||||
except UnicodeDecodeError:
|
||||
# dodgy client output or datastream corruption
|
||||
self.port.reset_input_buffer()
|
||||
|
||||
def shutdown(self):
|
||||
self.connected = False
|
||||
self.worker_thread.join()
|
||||
self.port.close()
|
||||
|
||||
def process_input(self, data):
|
||||
#print(data)
|
||||
self.responses.append(data)
|
||||
|
||||
def register(self, tokens, callback):
|
||||
self.applications.append((tokens, callback))
|
||||
|
||||
def send(self, protocol, packet_type, data = bytearray()):
|
||||
self.packet_transit = self.build_packet(protocol, packet_type, data)
|
||||
self.packet_status = 0
|
||||
self.transmit_attempt = 0
|
||||
|
||||
timeout = TimeOut(self.response_timeout * 20)
|
||||
while self.packet_status == 0:
|
||||
try:
|
||||
if timeout.timedout():
|
||||
raise ConnectionLost()
|
||||
self.transmit_packet(self.packet_transit)
|
||||
self.await_response()
|
||||
except ReadTimeout:
|
||||
self.errors += 1
|
||||
#print("Packetloss detected..")
|
||||
self.packet_transit = None
|
||||
|
||||
def await_response(self):
|
||||
timeout = TimeOut(self.response_timeout)
|
||||
while not len(self.responses):
|
||||
time.sleep(0.00001)
|
||||
if timeout.timedout():
|
||||
raise ReadTimeout()
|
||||
|
||||
while len(self.responses):
|
||||
token, data = self.responses.popleft()
|
||||
switch = {'ok' : self.response_ok, 'rs': self.response_resend, 'ss' : self.response_stream_sync, 'fe' : self.response_fatal_error}
|
||||
switch[token](data)
|
||||
|
||||
def send_ascii(self, data, send_and_forget = False):
|
||||
self.packet_transit = bytearray(data, "utf8") + b'\n'
|
||||
self.packet_status = 0
|
||||
self.transmit_attempt = 0
|
||||
|
||||
timeout = TimeOut(self.response_timeout * 20)
|
||||
while self.packet_status == 0:
|
||||
try:
|
||||
if timeout.timedout():
|
||||
return
|
||||
self.port.write(self.packet_transit)
|
||||
if send_and_forget:
|
||||
self.packet_status = 1
|
||||
else:
|
||||
self.await_response_ascii()
|
||||
except ReadTimeout:
|
||||
self.errors += 1
|
||||
#print("Packetloss detected..")
|
||||
except serial.serialutil.SerialException:
|
||||
return
|
||||
self.packet_transit = None
|
||||
|
||||
def await_response_ascii(self):
|
||||
timeout = TimeOut(self.response_timeout)
|
||||
while not len(self.responses):
|
||||
time.sleep(0.00001)
|
||||
if timeout.timedout():
|
||||
raise ReadTimeout()
|
||||
token, data = self.responses.popleft()
|
||||
self.packet_status = 1
|
||||
|
||||
def corrupt_array(self, data):
|
||||
rid = random.randint(0, len(data) - 1)
|
||||
data[rid] ^= 0xAA
|
||||
return data
|
||||
|
||||
def transmit_packet(self, packet):
|
||||
packet = bytearray(packet)
|
||||
if(self.simulate_errors > 0 and random.random() > (1.0 - self.simulate_errors)):
|
||||
if random.random() > 0.9:
|
||||
#random data drop
|
||||
start = random.randint(0, len(packet))
|
||||
end = start + random.randint(1, 10)
|
||||
packet = packet[:start] + packet[end:]
|
||||
#print("Dropping {0} bytes".format(end - start))
|
||||
else:
|
||||
#random corruption
|
||||
packet = self.corrupt_array(packet)
|
||||
#print("Single byte corruption")
|
||||
self.port.write(packet)
|
||||
self.transmit_attempt += 1
|
||||
|
||||
def build_packet(self, protocol, packet_type, data = bytearray()):
|
||||
PACKET_TOKEN = 0xB5AD
|
||||
|
||||
if len(data) > self.max_block_size:
|
||||
raise PayloadOverflow()
|
||||
|
||||
packet_buffer = bytearray()
|
||||
|
||||
packet_buffer += self.pack_int8(self.sync) # 8bit sync id
|
||||
packet_buffer += self.pack_int4_2(protocol, packet_type) # 4 bit protocol id, 4 bit packet type
|
||||
packet_buffer += self.pack_int16(len(data)) # 16bit packet length
|
||||
packet_buffer += self.pack_int16(self.build_checksum(packet_buffer)) # 16bit header checksum
|
||||
|
||||
if len(data):
|
||||
packet_buffer += data
|
||||
packet_buffer += self.pack_int16(self.build_checksum(packet_buffer))
|
||||
|
||||
packet_buffer = self.pack_int16(PACKET_TOKEN) + packet_buffer # 16bit start token, not included in checksum
|
||||
return packet_buffer
|
||||
|
||||
# checksum 16 fletchers
|
||||
def checksum(self, cs, value):
|
||||
cs_low = (((cs & 0xFF) + value) % 255);
|
||||
return ((((cs >> 8) + cs_low) % 255) << 8) | cs_low;
|
||||
|
||||
def build_checksum(self, buffer):
|
||||
cs = 0
|
||||
for b in buffer:
|
||||
cs = self.checksum(cs, b)
|
||||
return cs
|
||||
|
||||
def pack_int32(self, value):
|
||||
return value.to_bytes(4, byteorder='little')
|
||||
|
||||
def pack_int16(self, value):
|
||||
return value.to_bytes(2, byteorder='little')
|
||||
|
||||
def pack_int8(self, value):
|
||||
return value.to_bytes(1, byteorder='little')
|
||||
|
||||
def pack_int4_2(self, vh, vl):
|
||||
value = ((vh & 0xF) << 4) | (vl & 0xF)
|
||||
return value.to_bytes(1, byteorder='little')
|
||||
|
||||
def connect(self):
|
||||
print("Connecting: Switching Marlin to Binary Protocol...")
|
||||
self.send_ascii("M28B1")
|
||||
self.send(0, 1)
|
||||
|
||||
def disconnect(self):
|
||||
self.send(0, 2)
|
||||
self.syncronised = False
|
||||
|
||||
def response_ok(self, data):
|
||||
try:
|
||||
packet_id = int(data);
|
||||
except ValueError:
|
||||
return
|
||||
if packet_id != self.sync:
|
||||
raise SycronisationError()
|
||||
self.sync = (self.sync + 1) % 256
|
||||
self.packet_status = 1
|
||||
|
||||
def response_resend(self, data):
|
||||
packet_id = int(data);
|
||||
self.errors += 1
|
||||
if not self.syncronised:
|
||||
print("Retrying syncronisation")
|
||||
elif packet_id != self.sync:
|
||||
raise SycronisationError()
|
||||
|
||||
def response_stream_sync(self, data):
|
||||
sync, max_block_size, protocol_version = data.split(',')
|
||||
self.sync = int(sync)
|
||||
self.max_block_size = int(max_block_size)
|
||||
self.block_size = self.max_block_size if self.max_block_size < self.block_size else self.block_size
|
||||
self.protocol_version = protocol_version
|
||||
self.packet_status = 1
|
||||
self.syncronised = True
|
||||
print("Connection synced [{0}], binary protocol version {1}, {2} byte payload buffer".format(self.sync, self.protocol_version, self.max_block_size))
|
||||
|
||||
def response_fatal_error(self, data):
|
||||
raise FatalError()
|
||||
|
||||
|
||||
class FileTransferProtocol(object):
|
||||
protocol_id = 1
|
||||
|
||||
class Packet(object):
|
||||
QUERY = 0
|
||||
OPEN = 1
|
||||
CLOSE = 2
|
||||
WRITE = 3
|
||||
ABORT = 4
|
||||
|
||||
responses = deque()
|
||||
def __init__(self, protocol, timeout = None):
|
||||
protocol.register(['PFT:success', 'PFT:version:', 'PFT:fail', 'PFT:busy', 'PFT:ioerror', 'PTF:invalid'], self.process_input)
|
||||
self.protocol = protocol
|
||||
self.response_timeout = timeout or protocol.response_timeout
|
||||
|
||||
def process_input(self, data):
|
||||
#print(data)
|
||||
self.responses.append(data)
|
||||
|
||||
def await_response(self, timeout = None):
|
||||
timeout = TimeOut(timeout or self.response_timeout)
|
||||
while not len(self.responses):
|
||||
time.sleep(0.0001)
|
||||
if timeout.timedout():
|
||||
raise ReadTimeout()
|
||||
|
||||
return self.responses.popleft()
|
||||
|
||||
def connect(self):
|
||||
self.protocol.send(FileTransferProtocol.protocol_id, FileTransferProtocol.Packet.QUERY);
|
||||
|
||||
token, data = self.await_response()
|
||||
if token != 'PFT:version:':
|
||||
return False
|
||||
|
||||
self.version, _, compression = data.split(':')
|
||||
if compression != 'none':
|
||||
algorithm, window, lookahead = compression.split(',')
|
||||
self.compression = {'algorithm': algorithm, 'window': int(window), 'lookahead': int(lookahead)}
|
||||
else:
|
||||
self.compression = {'algorithm': 'none'}
|
||||
|
||||
print("File Transfer version: {0}, compression: {1}".format(self.version, self.compression['algorithm']))
|
||||
|
||||
def open(self, filename, compression, dummy):
|
||||
payload = b'\1' if dummy else b'\0' # dummy transfer
|
||||
payload += b'\1' if compression else b'\0' # payload compression
|
||||
payload += bytearray(filename, 'utf8') + b'\0'# target filename + null terminator
|
||||
|
||||
timeout = TimeOut(5000)
|
||||
token = None
|
||||
self.protocol.send(FileTransferProtocol.protocol_id, FileTransferProtocol.Packet.OPEN, payload);
|
||||
while token != 'PFT:success' and not timeout.timedout():
|
||||
try:
|
||||
token, data = self.await_response(1000)
|
||||
if token == 'PFT:success':
|
||||
print(filename,"opened")
|
||||
return
|
||||
elif token == 'PFT:busy':
|
||||
print("Broken transfer detected, purging")
|
||||
self.abort()
|
||||
time.sleep(0.1)
|
||||
self.protocol.send(FileTransferProtocol.protocol_id, FileTransferProtocol.Packet.OPEN, payload);
|
||||
timeout.reset()
|
||||
elif token == 'PFT:fail':
|
||||
raise Exception("Can not open file on client")
|
||||
except ReadTimeout:
|
||||
pass
|
||||
raise ReadTimeout()
|
||||
|
||||
def write(self, data):
|
||||
self.protocol.send(FileTransferProtocol.protocol_id, FileTransferProtocol.Packet.WRITE, data);
|
||||
|
||||
def close(self):
|
||||
self.protocol.send(FileTransferProtocol.protocol_id, FileTransferProtocol.Packet.CLOSE);
|
||||
token, data = self.await_response(1000)
|
||||
if token == 'PFT:success':
|
||||
print("File closed")
|
||||
return True
|
||||
elif token == 'PFT:ioerror':
|
||||
print("Client storage device IO error")
|
||||
return False
|
||||
elif token == 'PFT:invalid':
|
||||
print("No open file")
|
||||
return False
|
||||
|
||||
def abort(self):
|
||||
self.protocol.send(FileTransferProtocol.protocol_id, FileTransferProtocol.Packet.ABORT);
|
||||
token, data = self.await_response()
|
||||
if token == 'PFT:success':
|
||||
print("Transfer Aborted")
|
||||
|
||||
def copy(self, filename, dest_filename, compression, dummy):
|
||||
self.connect()
|
||||
|
||||
compression_support = heatshrink_exists and self.compression['algorithm'] == 'heatshrink' and compression
|
||||
if compression and (not heatshrink_exists or not self.compression['algorithm'] == 'heatshrink'):
|
||||
print("Compression not supported by client")
|
||||
#compression_support = False
|
||||
|
||||
data = open(filename, "rb").read()
|
||||
filesize = len(data)
|
||||
|
||||
self.open(dest_filename, compression_support, dummy)
|
||||
|
||||
block_size = self.protocol.block_size
|
||||
if compression_support:
|
||||
data = heatshrink.encode(data, window_sz2=self.compression['window'], lookahead_sz2=self.compression['lookahead'])
|
||||
|
||||
cratio = filesize / len(data)
|
||||
|
||||
blocks = math.floor((len(data) + block_size - 1) / block_size)
|
||||
kibs = 0
|
||||
dump_pctg = 0
|
||||
start_time = millis()
|
||||
for i in range(blocks):
|
||||
start = block_size * i
|
||||
end = start + block_size
|
||||
self.write(data[start:end])
|
||||
kibs = (( (i+1) * block_size) / 1024) / (millis() + 1 - start_time) * 1000
|
||||
if (i / blocks) >= dump_pctg:
|
||||
print("\r{0:2.0f}% {1:4.2f}KiB/s {2} Errors: {3}".format((i / blocks) * 100, kibs, "[{0:4.2f}KiB/s]".format(kibs * cratio) if compression_support else "", self.protocol.errors), end='')
|
||||
dump_pctg += 0.1
|
||||
if self.protocol.errors > 0:
|
||||
# Dump last status (errors may not be visible)
|
||||
print("\r{0:2.0f}% {1:4.2f}KiB/s {2} Errors: {3} - Aborting...".format((i / blocks) * 100, kibs, "[{0:4.2f}KiB/s]".format(kibs * cratio) if compression_support else "", self.protocol.errors), end='')
|
||||
print("") # New line to break the transfer speed line
|
||||
self.close()
|
||||
print("Transfer aborted due to protocol errors")
|
||||
#raise Exception("Transfer aborted due to protocol errors")
|
||||
return False;
|
||||
print("\r{0:2.0f}% {1:4.2f}KiB/s {2} Errors: {3}".format(100, kibs, "[{0:4.2f}KiB/s]".format(kibs * cratio) if compression_support else "", self.protocol.errors)) # no one likes transfers finishing at 99.8%
|
||||
|
||||
if not self.close():
|
||||
print("Transfer failed")
|
||||
return False
|
||||
print("Transfer complete")
|
||||
return True
|
||||
|
||||
|
||||
class EchoProtocol(object):
|
||||
def __init__(self, protocol):
|
||||
protocol.register(['echo:'], self.process_input)
|
||||
self.protocol = protocol
|
||||
|
||||
def process_input(self, data):
|
||||
print(data)
|
||||
@@ -0,0 +1,304 @@
|
||||
/**************************************\
|
||||
* *
|
||||
* OpenSCAD Mesh Display *
|
||||
* by Thinkyhead - April 2017 *
|
||||
* *
|
||||
* Copy the grid output from Marlin, *
|
||||
* paste below as shown, and use *
|
||||
* OpenSCAD to see a visualization *
|
||||
* of your mesh. *
|
||||
* *
|
||||
\**************************************/
|
||||
|
||||
$t = 0.15; // comment out during animation!
|
||||
X = 0; Y = 1;
|
||||
L = 0; R = 1; F = 2; B = 3;
|
||||
|
||||
//
|
||||
// Sample Mesh - Replace with your own
|
||||
//
|
||||
measured_z = [
|
||||
[ -1.20, -1.13, -1.09, -1.03, -1.19 ],
|
||||
[ -1.16, -1.25, -1.27, -1.25, -1.08 ],
|
||||
[ -1.13, -1.26, -1.39, -1.31, -1.18 ],
|
||||
[ -1.09, -1.20, -1.26, -1.21, -1.18 ],
|
||||
[ -1.13, -0.99, -1.03, -1.06, -1.32 ]
|
||||
];
|
||||
|
||||
//
|
||||
// An offset to add to all points in the mesh
|
||||
//
|
||||
zadjust = 0;
|
||||
|
||||
//
|
||||
// Mesh characteristics
|
||||
//
|
||||
bed_size = [ 200, 200 ];
|
||||
|
||||
mesh_inset = [ 10, 10, 10, 10 ]; // L, F, R, B
|
||||
|
||||
mesh_bounds = [
|
||||
[ mesh_inset[L], mesh_inset[F] ],
|
||||
[ bed_size[X] - mesh_inset[R], bed_size[Y] - mesh_inset[B] ]
|
||||
];
|
||||
|
||||
mesh_size = mesh_bounds[1] - mesh_bounds[0];
|
||||
|
||||
// NOTE: Marlin meshes already subtract the probe offset
|
||||
NAN = 0; // Z to use for un-measured points
|
||||
|
||||
//
|
||||
// Geometry
|
||||
//
|
||||
|
||||
max_z_scale = 100; // Scale at Time 0.5
|
||||
min_z_scale = 10; // Scale at Time 0.0 and 1.0
|
||||
thickness = 0.5; // thickness of the mesh triangles
|
||||
tesselation = 1; // levels of tesselation from 0-2
|
||||
alternation = 2; // direction change modulus (try it)
|
||||
|
||||
//
|
||||
// Appearance
|
||||
//
|
||||
|
||||
show_plane = true;
|
||||
show_labels = true;
|
||||
show_coords = true;
|
||||
arrow_length = 5;
|
||||
|
||||
label_font_lg = "Arial";
|
||||
label_font_sm = "Arial";
|
||||
mesh_color = [1,1,1,0.5];
|
||||
plane_color = [0.4,0.6,0.9,0.6];
|
||||
|
||||
//================================================ Derive useful values
|
||||
|
||||
big_z = max_2D(measured_z,0);
|
||||
lil_z = min_2D(measured_z,0);
|
||||
|
||||
mean_value = (big_z + lil_z) / 2.0;
|
||||
|
||||
mesh_points_y = len(measured_z);
|
||||
mesh_points_x = len(measured_z[0]);
|
||||
|
||||
xspace = mesh_size[X] / (mesh_points_x - 1);
|
||||
yspace = mesh_size[Y] / (mesh_points_y - 1);
|
||||
|
||||
// At $t=0 and $t=1 scale will be 100%
|
||||
z_scale_factor = min_z_scale + (($t > 0.5) ? 1.0 - $t : $t) * (max_z_scale - min_z_scale) * 2;
|
||||
|
||||
//
|
||||
// Min and max recursive functions for 1D and 2D arrays
|
||||
// Return the smallest or largest value in the array
|
||||
//
|
||||
function some_1D(b,i) = (i<len(b)-1) ? (b[i] && some_1D(b,i+1)) : b[i] != 0;
|
||||
function some_2D(a,j) = (j<len(a)-1) ? some_2D(a,j+1) : some_1D(a[j], 0);
|
||||
function min_1D(b,i) = (i<len(b)-1) ? min(b[i], min_1D(b,i+1)) : b[i];
|
||||
function min_2D(a,j) = (j<len(a)-1) ? min_2D(a,j+1) : min_1D(a[j], 0);
|
||||
function max_1D(b,i) = (i<len(b)-1) ? max(b[i], max_1D(b,i+1)) : b[i];
|
||||
function max_2D(a,j) = (j<len(a)-1) ? max_2D(a,j+1) : max_1D(a[j], 0);
|
||||
|
||||
//
|
||||
// Get the corner probe points of a grid square.
|
||||
//
|
||||
// Input : x,y grid indexes
|
||||
// Output : An array of the 4 corner points
|
||||
//
|
||||
function grid_square(x,y) = [
|
||||
[x * xspace, y * yspace, z_scale_factor * (measured_z[y][x] - mean_value)],
|
||||
[x * xspace, (y+1) * yspace, z_scale_factor * (measured_z[y+1][x] - mean_value)],
|
||||
[(x+1) * xspace, (y+1) * yspace, z_scale_factor * (measured_z[y+1][x+1] - mean_value)],
|
||||
[(x+1) * xspace, y * yspace, z_scale_factor * (measured_z[y][x+1] - mean_value)]
|
||||
];
|
||||
|
||||
// The corner point of a grid square with Z centered on the mean
|
||||
function pos(x,y,z) = [x * xspace, y * yspace, z_scale_factor * (z - mean_value)];
|
||||
|
||||
//
|
||||
// Draw the point markers and labels
|
||||
//
|
||||
module point_markers(show_home=true) {
|
||||
// Mark the home position 0,0
|
||||
if (show_home)
|
||||
translate([1,1]) color([0,0,0,0.25])
|
||||
cylinder(r=1, h=z_scale_factor, center=true);
|
||||
|
||||
for (x=[0:mesh_points_x-1], y=[0:mesh_points_y-1]) {
|
||||
z = measured_z[y][x] - zadjust;
|
||||
down = z < mean_value;
|
||||
xyz = pos(x, y, z);
|
||||
translate([ xyz[0], xyz[1] ]) {
|
||||
|
||||
// Show the XY as well as the Z!
|
||||
if (show_coords) {
|
||||
color("black")
|
||||
translate([0,0,0.5]) {
|
||||
$fn=8;
|
||||
rotate([0,0]) {
|
||||
posx = floor(mesh_bounds[0][X] + x * xspace);
|
||||
posy = floor(mesh_bounds[0][Y] + y * yspace);
|
||||
text(str(posx, ",", posy), 2, label_font_sm, halign="center", valign="center");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
translate([ 0, 0, xyz[2] ]) {
|
||||
// Label each point with the Z
|
||||
v = z - mean_value;
|
||||
if (show_labels) {
|
||||
|
||||
color(abs(v) < 0.1 ? [0,0.5,0] : [0.25,0,0])
|
||||
translate([0,0,down?-10:10]) {
|
||||
|
||||
$fn=8;
|
||||
rotate([90,0])
|
||||
text(str(z), 6, label_font_lg, halign="center", valign="center");
|
||||
|
||||
if (v)
|
||||
translate([0,0,down?-6:6]) rotate([90,0])
|
||||
text(str(down || !v ? "" : "+", v), 3, label_font_sm, halign="center", valign="center");
|
||||
}
|
||||
}
|
||||
|
||||
// Show an arrow pointing up or down
|
||||
if (v) {
|
||||
rotate([0, down ? 180 : 0]) translate([0,0,-1])
|
||||
cylinder(
|
||||
r1=0.5,
|
||||
r2=0.1,
|
||||
h=arrow_length, $fn=12, center=1
|
||||
);
|
||||
}
|
||||
else
|
||||
color([1,0,1,0.4]) sphere(r=1.0, $fn=20, center=1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Split a square on the diagonal into
|
||||
// two triangles and render them.
|
||||
//
|
||||
// s : a square
|
||||
// alt : a flag to split on the other diagonal
|
||||
//
|
||||
module tesselated_square(s, alt=false) {
|
||||
add = [0,0,thickness];
|
||||
p1 = [
|
||||
s[0], s[1], s[2], s[3],
|
||||
s[0]+add, s[1]+add, s[2]+add, s[3]+add
|
||||
];
|
||||
f1 = alt
|
||||
? [ [0,1,3], [4,5,1,0], [4,7,5], [5,7,3,1], [7,4,0,3] ]
|
||||
: [ [0,1,2], [4,5,1,0], [4,6,5], [5,6,2,1], [6,4,0,2] ];
|
||||
f2 = alt
|
||||
? [ [1,2,3], [5,6,2,1], [5,6,7], [6,7,3,2], [7,5,1,3] ]
|
||||
: [ [0,2,3], [4,6,2,0], [4,7,6], [6,7,3,2], [7,4,0,3] ];
|
||||
|
||||
// Use the other diagonal
|
||||
polyhedron(points=p1, faces=f1);
|
||||
polyhedron(points=p1, faces=f2);
|
||||
}
|
||||
|
||||
/**
|
||||
* The simplest mesh display
|
||||
*/
|
||||
module simple_mesh(show_plane=show_plane) {
|
||||
if (show_plane) color(plane_color) cube([mesh_size[X], mesh_size[Y], thickness]);
|
||||
color(mesh_color)
|
||||
for (x=[0:mesh_points_x-2], y=[0:mesh_points_y-2])
|
||||
tesselated_square(grid_square(x, y));
|
||||
}
|
||||
|
||||
/**
|
||||
* Subdivide the mesh into smaller squares.
|
||||
*/
|
||||
module bilinear_mesh(show_plane=show_plane,tesselation=tesselation) {
|
||||
if (show_plane) color(plane_color) translate([-5,-5]) cube([mesh_size[X]+10, mesh_size[Y]+10, thickness]);
|
||||
|
||||
if (some_2D(measured_z, 0)) {
|
||||
|
||||
tesselation = tesselation % 4;
|
||||
color(mesh_color)
|
||||
for (x=[0:mesh_points_x-2], y=[0:mesh_points_y-2]) {
|
||||
square = grid_square(x, y);
|
||||
if (tesselation < 1) {
|
||||
tesselated_square(square,(x%alternation)-(y%alternation));
|
||||
}
|
||||
else {
|
||||
subdiv_4 = subdivided_square(square);
|
||||
if (tesselation < 2) {
|
||||
for (i=[0:3]) tesselated_square(subdiv_4[i],i%alternation);
|
||||
}
|
||||
else {
|
||||
for (i=[0:3]) {
|
||||
subdiv_16 = subdivided_square(subdiv_4[i]);
|
||||
if (tesselation < 3) {
|
||||
for (j=[0:3]) tesselated_square(subdiv_16[j],j%alternation);
|
||||
}
|
||||
else {
|
||||
for (j=[0:3]) {
|
||||
subdiv_64 = subdivided_square(subdiv_16[j]);
|
||||
if (tesselation < 4) {
|
||||
for (k=[0:3]) tesselated_square(subdiv_64[k]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Subdivision helpers
|
||||
//
|
||||
function ctrz(a) = (a[0][2]+a[1][2]+a[3][2]+a[2][2])/4;
|
||||
function avgx(a,i) = (a[i][0]+a[(i+1)%4][0])/2;
|
||||
function avgy(a,i) = (a[i][1]+a[(i+1)%4][1])/2;
|
||||
function avgz(a,i) = (a[i][2]+a[(i+1)%4][2])/2;
|
||||
|
||||
//
|
||||
// Convert one square into 4, applying bilinear averaging
|
||||
//
|
||||
// Input : 1 square (4 points)
|
||||
// Output : An array of 4 squares
|
||||
//
|
||||
function subdivided_square(a) = [
|
||||
[ // SW square
|
||||
a[0], // SW
|
||||
[a[0][0],avgy(a,0),avgz(a,0)], // CW
|
||||
[avgx(a,1),avgy(a,0),ctrz(a)], // CC
|
||||
[avgx(a,1),a[0][1],avgz(a,3)] // SC
|
||||
],
|
||||
[ // NW square
|
||||
[a[0][0],avgy(a,0),avgz(a,0)], // CW
|
||||
a[1], // NW
|
||||
[avgx(a,1),a[1][1],avgz(a,1)], // NC
|
||||
[avgx(a,1),avgy(a,0),ctrz(a)] // CC
|
||||
],
|
||||
[ // NE square
|
||||
[avgx(a,1),avgy(a,0),ctrz(a)], // CC
|
||||
[avgx(a,1),a[1][1],avgz(a,1)], // NC
|
||||
a[2], // NE
|
||||
[a[2][0],avgy(a,0),avgz(a,2)] // CE
|
||||
],
|
||||
[ // SE square
|
||||
[avgx(a,1),a[0][1],avgz(a,3)], // SC
|
||||
[avgx(a,1),avgy(a,0),ctrz(a)], // CC
|
||||
[a[2][0],avgy(a,0),avgz(a,2)], // CE
|
||||
a[3] // SE
|
||||
]
|
||||
];
|
||||
|
||||
|
||||
//================================================ Run the plan
|
||||
|
||||
translate([-mesh_size[X] / 2, -mesh_size[Y] / 2]) {
|
||||
$fn = 12;
|
||||
point_markers();
|
||||
bilinear_mesh();
|
||||
}
|
||||
53
hannoprint/Marlin-2.1.2.1/buildroot/share/scripts/createSpeedLookupTable.py
Executable file
53
hannoprint/Marlin-2.1.2.1/buildroot/share/scripts/createSpeedLookupTable.py
Executable file
@@ -0,0 +1,53 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
from __future__ import print_function
|
||||
from __future__ import division
|
||||
|
||||
""" Generate the stepper delay lookup table for Marlin firmware. """
|
||||
|
||||
import argparse
|
||||
|
||||
__author__ = "Ben Gamari <bgamari@gmail.com>"
|
||||
__copyright__ = "Copyright 2012, Ben Gamari"
|
||||
__license__ = "GPL"
|
||||
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument('-f', '--cpu-freq', type=int, default=16, help='CPU clockrate in MHz (default=16)')
|
||||
parser.add_argument('-d', '--divider', type=int, default=8, help='Timer/counter pre-scale divider (default=8)')
|
||||
args = parser.parse_args()
|
||||
|
||||
cpu_freq = args.cpu_freq * 1000000
|
||||
timer_freq = cpu_freq / args.divider
|
||||
|
||||
print("#ifndef SPEED_LOOKUPTABLE_H")
|
||||
print("#define SPEED_LOOKUPTABLE_H")
|
||||
print()
|
||||
print('#include "MarlinCore.h"')
|
||||
print()
|
||||
|
||||
print("const uint16_t speed_lookuptable_fast[256][2] PROGMEM = {")
|
||||
a = [ timer_freq / ((i*256)+(args.cpu_freq*2)) for i in range(256) ]
|
||||
b = [ a[i] - a[i+1] for i in range(255) ]
|
||||
b.append(b[-1])
|
||||
for i in range(32):
|
||||
print(" ", end=' ')
|
||||
for j in range(8):
|
||||
print("{%d, %d}," % (a[8*i+j], b[8*i+j]), end=' ')
|
||||
print()
|
||||
print("};")
|
||||
print()
|
||||
|
||||
print("const uint16_t speed_lookuptable_slow[256][2] PROGMEM = {")
|
||||
a = [ timer_freq / ((i*8)+(args.cpu_freq*2)) for i in range(256) ]
|
||||
b = [ a[i] - a[i+1] for i in range(255) ]
|
||||
b.append(b[-1])
|
||||
for i in range(32):
|
||||
print(" ", end=' ')
|
||||
for j in range(8):
|
||||
print("{%d, %d}," % (a[8*i+j], b[8*i+j]), end=' ')
|
||||
print()
|
||||
print("};")
|
||||
print()
|
||||
|
||||
print("#endif")
|
||||
|
||||
@@ -0,0 +1,157 @@
|
||||
#!/usr/bin/env python
|
||||
"""Thermistor Value Lookup Table Generator
|
||||
|
||||
Generates lookup to temperature values for use in a microcontroller in C format based on:
|
||||
https://en.wikipedia.org/wiki/Steinhart-Hart_equation
|
||||
|
||||
The main use is for Arduino programs that read data from the circuit board described here:
|
||||
https://reprap.org/wiki/Temperature_Sensor_v2.0
|
||||
|
||||
Usage: python createTemperatureLookupMarlin.py [options]
|
||||
|
||||
Options:
|
||||
-h, --help show this help
|
||||
--rp=... pull-up resistor
|
||||
--t1=ttt:rrr low temperature temperature:resistance point (around 25 degC)
|
||||
--t2=ttt:rrr middle temperature temperature:resistance point (around 150 degC)
|
||||
--t3=ttt:rrr high temperature temperature:resistance point (around 250 degC)
|
||||
--num-temps=... the number of temperature points to calculate (default: 36)
|
||||
"""
|
||||
|
||||
from __future__ import print_function
|
||||
from __future__ import division
|
||||
|
||||
from math import *
|
||||
import sys,getopt
|
||||
|
||||
"Constants"
|
||||
ZERO = 273.15 # zero point of Kelvin scale
|
||||
VADC = 5 # ADC voltage
|
||||
VCC = 5 # supply voltage
|
||||
ARES = pow(2,10) # 10 Bit ADC resolution
|
||||
VSTEP = VADC / ARES # ADC voltage resolution
|
||||
TMIN = 0 # lowest temperature in table
|
||||
TMAX = 350 # highest temperature in table
|
||||
|
||||
class Thermistor:
|
||||
"Class to do the thermistor maths"
|
||||
def __init__(self, rp, t1, r1, t2, r2, t3, r3):
|
||||
l1 = log(r1)
|
||||
l2 = log(r2)
|
||||
l3 = log(r3)
|
||||
y1 = 1.0 / (t1 + ZERO) # adjust scale
|
||||
y2 = 1.0 / (t2 + ZERO)
|
||||
y3 = 1.0 / (t3 + ZERO)
|
||||
x = (y2 - y1) / (l2 - l1)
|
||||
y = (y3 - y1) / (l3 - l1)
|
||||
c = (y - x) / ((l3 - l2) * (l1 + l2 + l3))
|
||||
b = x - c * (l1**2 + l2**2 + l1*l2)
|
||||
a = y1 - (b + l1**2 *c)*l1
|
||||
|
||||
if c < 0:
|
||||
print("//////////////////////////////////////////////////////////////////////////////////////")
|
||||
print("// WARNING: Negative coefficient 'c'! Something may be wrong with the measurements! //")
|
||||
print("//////////////////////////////////////////////////////////////////////////////////////")
|
||||
c = -c
|
||||
self.c1 = a # Steinhart-Hart coefficients
|
||||
self.c2 = b
|
||||
self.c3 = c
|
||||
self.rp = rp # pull-up resistance
|
||||
|
||||
def resol(self, adc):
|
||||
"Convert ADC reading into a resolution"
|
||||
res = self.temp(adc)-self.temp(adc+1)
|
||||
return res
|
||||
|
||||
def voltage(self, adc):
|
||||
"Convert ADC reading into a Voltage"
|
||||
return adc * VSTEP # convert the 10 bit ADC value to a voltage
|
||||
|
||||
def resist(self, adc):
|
||||
"Convert ADC reading into a resistance in Ohms"
|
||||
r = self.rp * self.voltage(adc) / (VCC - self.voltage(adc)) # resistance of thermistor
|
||||
return r
|
||||
|
||||
def temp(self, adc):
|
||||
"Convert ADC reading into a temperature in Celsius"
|
||||
l = log(self.resist(adc))
|
||||
Tinv = self.c1 + self.c2*l + self.c3* l**3 # inverse temperature
|
||||
return (1/Tinv) - ZERO # temperature
|
||||
|
||||
def adc(self, temp):
|
||||
"Convert temperature into a ADC reading"
|
||||
x = (self.c1 - (1.0 / (temp+ZERO))) / (2*self.c3)
|
||||
y = sqrt((self.c2 / (3*self.c3))**3 + x**2)
|
||||
r = exp((y-x)**(1.0/3) - (y+x)**(1.0/3))
|
||||
return (r / (self.rp + r)) * ARES
|
||||
|
||||
def main(argv):
|
||||
"Default values"
|
||||
t1 = 25 # low temperature in Kelvin (25 degC)
|
||||
r1 = 100000 # resistance at low temperature (10 kOhm)
|
||||
t2 = 150 # middle temperature in Kelvin (150 degC)
|
||||
r2 = 1641.9 # resistance at middle temperature (1.6 KOhm)
|
||||
t3 = 250 # high temperature in Kelvin (250 degC)
|
||||
r3 = 226.15 # resistance at high temperature (226.15 Ohm)
|
||||
rp = 4700 # pull-up resistor (4.7 kOhm)
|
||||
num_temps = 36 # number of entries for look-up table
|
||||
|
||||
try:
|
||||
opts, args = getopt.getopt(argv, "h", ["help", "rp=", "t1=", "t2=", "t3=", "num-temps="])
|
||||
except getopt.GetoptError as err:
|
||||
print(str(err))
|
||||
usage()
|
||||
sys.exit(2)
|
||||
|
||||
for opt, arg in opts:
|
||||
if opt in ("-h", "--help"):
|
||||
usage()
|
||||
sys.exit()
|
||||
elif opt == "--rp":
|
||||
rp = int(arg)
|
||||
elif opt == "--t1":
|
||||
arg = arg.split(':')
|
||||
t1 = float(arg[0])
|
||||
r1 = float(arg[1])
|
||||
elif opt == "--t2":
|
||||
arg = arg.split(':')
|
||||
t2 = float(arg[0])
|
||||
r2 = float(arg[1])
|
||||
elif opt == "--t3":
|
||||
arg = arg.split(':')
|
||||
t3 = float(arg[0])
|
||||
r3 = float(arg[1])
|
||||
elif opt == "--num-temps":
|
||||
num_temps = int(arg)
|
||||
|
||||
t = Thermistor(rp, t1, r1, t2, r2, t3, r3)
|
||||
increment = int((ARES - 1) / (num_temps - 1))
|
||||
step = int((TMIN - TMAX) / (num_temps - 1))
|
||||
low_bound = t.temp(ARES - 1)
|
||||
up_bound = t.temp(1)
|
||||
min_temp = int(TMIN if TMIN > low_bound else low_bound)
|
||||
max_temp = int(TMAX if TMAX < up_bound else up_bound)
|
||||
temps = list(range(max_temp, TMIN + step, step))
|
||||
|
||||
print("// Thermistor lookup table for Marlin")
|
||||
print("// ./createTemperatureLookupMarlin.py --rp=%s --t1=%s:%s --t2=%s:%s --t3=%s:%s --num-temps=%s" % (rp, t1, r1, t2, r2, t3, r3, num_temps))
|
||||
print("// Steinhart-Hart Coefficients: a=%.15g, b=%.15g, c=%.15g " % (t.c1, t.c2, t.c3))
|
||||
print("// Theoretical limits of thermistor: %.2f to %.2f degC" % (low_bound, up_bound))
|
||||
print()
|
||||
print("const short temptable[][2] PROGMEM = {")
|
||||
|
||||
for temp in temps:
|
||||
adc = t.adc(temp)
|
||||
print(" { OV(%7.2f), %4s }%s // v=%.3f\tr=%.3f\tres=%.3f degC/count" % (adc , temp, \
|
||||
',' if temp != temps[-1] else ' ', \
|
||||
t.voltage(adc), \
|
||||
t.resist( adc), \
|
||||
t.resol( adc) \
|
||||
))
|
||||
print("};")
|
||||
|
||||
def usage():
|
||||
print(__doc__)
|
||||
|
||||
if __name__ == "__main__":
|
||||
main(sys.argv[1:])
|
||||
47
hannoprint/Marlin-2.1.2.1/buildroot/share/scripts/findMissingTranslations.sh
Executable file
47
hannoprint/Marlin-2.1.2.1/buildroot/share/scripts/findMissingTranslations.sh
Executable file
@@ -0,0 +1,47 @@
|
||||
#!/usr/bin/env bash
|
||||
#
|
||||
# findMissingTranslations.sh
|
||||
#
|
||||
# Locate all language strings needing an update based on English
|
||||
#
|
||||
# Usage: findMissingTranslations.sh [language codes]
|
||||
#
|
||||
# If no language codes are specified then all languages will be checked
|
||||
#
|
||||
|
||||
LANGHOME="Marlin/src/lcd/language"
|
||||
|
||||
[ -d $LANGHOME ] && cd $LANGHOME
|
||||
|
||||
FILES=$(ls language_*.h | grep -v -E "(_en|_test)\.h" | sed -E 's/language_([^\.]+)\.h/\1/' | tr '\n' ' ')
|
||||
|
||||
# Get files matching the given arguments
|
||||
TEST_LANGS=""
|
||||
if [[ -n $@ ]]; then
|
||||
for K in "$@"; do
|
||||
for F in $FILES; do
|
||||
[[ "$F" != "${F%$K*}" ]] && TEST_LANGS+="$F "
|
||||
done
|
||||
done
|
||||
[[ -z $TEST_LANGS ]] && { echo "No languages matching $@." ; exit 0 ; }
|
||||
else
|
||||
TEST_LANGS=$FILES
|
||||
fi
|
||||
|
||||
echo "Missing strings for $TEST_LANGS..."
|
||||
|
||||
for WORD in $(awk '/LSTR/{print $2}' language_en.h); do
|
||||
[[ $WORD == "MSG_MARLIN" ]] && break
|
||||
LANG_LIST=""
|
||||
for LANG in $TEST_LANGS; do
|
||||
if [[ $(grep -c -E "^ *LSTR +$WORD\b" language_${LANG}.h) -eq 0 ]]; then
|
||||
INHERIT=$(awk '/using namespace/{print $3}' language_${LANG}.h | sed -E 's/Language_([a-zA-Z_]+)\s*;/\1/')
|
||||
if [[ -z $INHERIT || $INHERIT == "en" ]]; then
|
||||
LANG_LIST+=" $LANG"
|
||||
elif [[ $(grep -c -E "^ *LSTR +$WORD\b" language_${INHERIT}.h) -eq 0 ]]; then
|
||||
LANG_LIST+=" $LANG"
|
||||
fi
|
||||
fi
|
||||
done
|
||||
[[ -n $LANG_LIST ]] && printf "%-38s :%s\n" "$WORD" "$LANG_LIST"
|
||||
done
|
||||
188
hannoprint/Marlin-2.1.2.1/buildroot/share/scripts/g29_auto.py
Executable file
188
hannoprint/Marlin-2.1.2.1/buildroot/share/scripts/g29_auto.py
Executable file
@@ -0,0 +1,188 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
# This file is for preprocessing G-code and the new G29 Auto bed leveling from Marlin
|
||||
# It will analyze the first 2 layers and return the maximum size for this part
|
||||
# Then it will be replaced with g29_keyword = ';MarlinG29Script' with the new G29 LRFB.
|
||||
# The new file will be created in the same folder.
|
||||
|
||||
from __future__ import print_function
|
||||
|
||||
# Your G-code file/folder
|
||||
folder = './'
|
||||
my_file = 'test.gcode'
|
||||
|
||||
# this is the minimum of G1 instructions which should be between 2 different heights
|
||||
min_g1 = 3
|
||||
|
||||
# maximum number of lines to parse, I don't want to parse the complete file
|
||||
# only the first plane is we are interested in
|
||||
max_g1 = 100000000
|
||||
|
||||
# g29 keyword
|
||||
g29_keyword = 'g29'
|
||||
g29_keyword = g29_keyword.upper()
|
||||
|
||||
# output filename
|
||||
output_file = folder + 'g29_' + my_file
|
||||
# input filename
|
||||
input_file = folder + my_file
|
||||
|
||||
# minimum scan size
|
||||
min_size = 40
|
||||
probing_points = 3 # points x points
|
||||
|
||||
# other stuff
|
||||
min_x = 500
|
||||
min_y = min_x
|
||||
max_x = -500
|
||||
max_y = max_x
|
||||
last_z = 0.001
|
||||
|
||||
layer = 0
|
||||
lines_of_g1 = 0
|
||||
|
||||
gcode = []
|
||||
|
||||
|
||||
# return only g1-lines
|
||||
def has_g1(line):
|
||||
return line[:2].upper() == "G1"
|
||||
|
||||
|
||||
# find position in g1 (x,y,z)
|
||||
def find_axis(line, axis):
|
||||
found = False
|
||||
number = ""
|
||||
for char in line:
|
||||
if found:
|
||||
if char == ".":
|
||||
number += char
|
||||
elif char == "-":
|
||||
number += char
|
||||
else:
|
||||
try:
|
||||
int(char)
|
||||
number += char
|
||||
except ValueError:
|
||||
break
|
||||
else:
|
||||
found = char.upper() == axis.upper()
|
||||
try:
|
||||
return float(number)
|
||||
except ValueError:
|
||||
return None
|
||||
|
||||
|
||||
# save the min or max-values for each axis
|
||||
def set_mima(line):
|
||||
global min_x, max_x, min_y, max_y, last_z
|
||||
|
||||
current_x = find_axis(line, 'x')
|
||||
current_y = find_axis(line, 'y')
|
||||
|
||||
if current_x is not None:
|
||||
min_x = min(current_x, min_x)
|
||||
max_x = max(current_x, max_x)
|
||||
if current_y is not None:
|
||||
min_y = min(current_y, min_y)
|
||||
max_y = max(current_y, max_y)
|
||||
|
||||
return min_x, max_x, min_y, max_y
|
||||
|
||||
|
||||
# find z in the code and return it
|
||||
def find_z(gcode, start_at_line=0):
|
||||
for i in range(start_at_line, len(gcode)):
|
||||
my_z = find_axis(gcode[i], 'Z')
|
||||
if my_z is not None:
|
||||
return my_z, i
|
||||
|
||||
|
||||
def z_parse(gcode, start_at_line=0, end_at_line=0):
|
||||
i = start_at_line
|
||||
all_z = []
|
||||
line_between_z = []
|
||||
z_at_line = []
|
||||
# last_z = 0
|
||||
last_i = -1
|
||||
|
||||
while len(gcode) > i:
|
||||
try:
|
||||
z, i = find_z(gcode, i + 1)
|
||||
except TypeError:
|
||||
break
|
||||
|
||||
all_z.append(z)
|
||||
z_at_line.append(i)
|
||||
temp_line = i - last_i -1
|
||||
line_between_z.append(i - last_i - 1)
|
||||
# last_z = z
|
||||
last_i = i
|
||||
if 0 < end_at_line <= i or temp_line >= min_g1:
|
||||
# print('break at line {} at height {}'.format(i, z))
|
||||
break
|
||||
|
||||
line_between_z = line_between_z[1:]
|
||||
return all_z, line_between_z, z_at_line
|
||||
|
||||
|
||||
# get the lines which should be the first layer
|
||||
def get_lines(gcode, minimum):
|
||||
i = 0
|
||||
all_z, line_between_z, z_at_line = z_parse(gcode, end_at_line=max_g1)
|
||||
for count in line_between_z:
|
||||
i += 1
|
||||
if count > minimum:
|
||||
# print('layer: {}:{}'.format(z_at_line[i-1], z_at_line[i]))
|
||||
return z_at_line[i - 1], z_at_line[i]
|
||||
|
||||
|
||||
with open(input_file, 'r') as file:
|
||||
lines = 0
|
||||
for line in file:
|
||||
lines += 1
|
||||
if lines > 1000:
|
||||
break
|
||||
if has_g1(line):
|
||||
gcode.append(line)
|
||||
file.close()
|
||||
|
||||
start, end = get_lines(gcode, min_g1)
|
||||
for i in range(start, end):
|
||||
set_mima(gcode[i])
|
||||
|
||||
print('x_min:{} x_max:{}\ny_min:{} y_max:{}'.format(min_x, max_x, min_y, max_y))
|
||||
|
||||
# resize min/max - values for minimum scan
|
||||
if max_x - min_x < min_size:
|
||||
offset_x = int((min_size - (max_x - min_x)) / 2 + 0.5) # int round up
|
||||
# print('min_x! with {}'.format(int(max_x - min_x)))
|
||||
min_x = int(min_x) - offset_x
|
||||
max_x = int(max_x) + offset_x
|
||||
if max_y - min_y < min_size:
|
||||
offset_y = int((min_size - (max_y - min_y)) / 2 + 0.5) # int round up
|
||||
# print('min_y! with {}'.format(int(max_y - min_y)))
|
||||
min_y = int(min_y) - offset_y
|
||||
max_y = int(max_y) + offset_y
|
||||
|
||||
|
||||
new_command = 'G29 L{0} R{1} F{2} B{3} P{4}\n'.format(min_x,
|
||||
max_x,
|
||||
min_y,
|
||||
max_y,
|
||||
probing_points)
|
||||
|
||||
out_file = open(output_file, 'w')
|
||||
in_file = open(input_file, 'r')
|
||||
|
||||
for line in in_file:
|
||||
if line[:len(g29_keyword)].upper() == g29_keyword:
|
||||
out_file.write(new_command)
|
||||
print('write G29')
|
||||
else:
|
||||
out_file.write(line)
|
||||
|
||||
file.close()
|
||||
out_file.close()
|
||||
|
||||
print('auto G29 finished')
|
||||
@@ -0,0 +1,64 @@
|
||||
#!/usr/bin/env python3
|
||||
#
|
||||
# Marlin 3D Printer Firmware
|
||||
# Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
||||
#
|
||||
# Based on Sprinter and grbl.
|
||||
# Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
|
||||
#
|
||||
# This program is free software: you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation, either version 3 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
#
|
||||
|
||||
# Generate Marlin TFT Images from bitmaps/PNG/JPG
|
||||
|
||||
import sys,struct
|
||||
from PIL import Image
|
||||
|
||||
def image2bin(image, output_file):
|
||||
if output_file.endswith(('.c', '.cpp')):
|
||||
f = open(output_file, 'wt')
|
||||
is_cpp = True
|
||||
f.write("const uint16_t image[%d] = {\n" % (image.size[1] * image.size[0]))
|
||||
else:
|
||||
f = open(output_file, 'wb')
|
||||
is_cpp = False
|
||||
pixs = image.load()
|
||||
for y in range(image.size[1]):
|
||||
for x in range(image.size[0]):
|
||||
R = pixs[x, y][0] >> 3
|
||||
G = pixs[x, y][1] >> 2
|
||||
B = pixs[x, y][2] >> 3
|
||||
rgb = (R << 11) | (G << 5) | B
|
||||
if is_cpp:
|
||||
strHex = '0x{0:04X}, '.format(rgb)
|
||||
f.write(strHex)
|
||||
else:
|
||||
f.write(struct.pack("B", (rgb & 0xFF)))
|
||||
f.write(struct.pack("B", (rgb >> 8) & 0xFF))
|
||||
if is_cpp:
|
||||
f.write("\n")
|
||||
if is_cpp:
|
||||
f.write("};\n")
|
||||
f.close()
|
||||
|
||||
if len(sys.argv) <= 2:
|
||||
print("Utility to export a image in Marlin TFT friendly format.")
|
||||
print("It will dump a raw bin RGB565 image or create a CPP file with an array of 16 bit image pixels.")
|
||||
print("Usage: gen-tft-image.py INPUT_IMAGE.(png|bmp|jpg) OUTPUT_FILE.(cpp|bin)")
|
||||
print("Author: rhapsodyv")
|
||||
exit(1)
|
||||
|
||||
output_img = sys.argv[2]
|
||||
img = Image.open(sys.argv[1])
|
||||
image2bin(img, output_img)
|
||||
@@ -0,0 +1,15 @@
|
||||
#!/usr/bin/env python
|
||||
"""
|
||||
Extract the builds used in Github CI, so that we can run them locally
|
||||
"""
|
||||
import yaml
|
||||
|
||||
# Set the yaml file to parse
|
||||
yaml_file = '.github/workflows/test-builds.yml'
|
||||
|
||||
# Parse the yaml file, and load it into a dictionary (github_configuration)
|
||||
with open(yaml_file) as f:
|
||||
github_configuration = yaml.safe_load(f)
|
||||
|
||||
# Print out the test platforms
|
||||
print(' '.join(github_configuration['jobs']['test_builds']['strategy']['matrix']['test-platform']))
|
||||
177
hannoprint/Marlin-2.1.2.1/buildroot/share/scripts/pinsformat.js
Executable file
177
hannoprint/Marlin-2.1.2.1/buildroot/share/scripts/pinsformat.js
Executable file
@@ -0,0 +1,177 @@
|
||||
#!/usr/bin/env node
|
||||
|
||||
//
|
||||
// Formatter script for pins_MYPINS.h files
|
||||
//
|
||||
// Usage: mffmt [infile] [outfile]
|
||||
//
|
||||
// With no parameters convert STDIN to STDOUT
|
||||
//
|
||||
|
||||
const fs = require("fs");
|
||||
|
||||
// String lpad / rpad
|
||||
String.prototype.lpad = function(len, chr) {
|
||||
if (!len) return this;
|
||||
if (chr === undefined) chr = ' ';
|
||||
var s = this+'', need = len - s.length;
|
||||
if (need > 0) s = new Array(need+1).join(chr) + s;
|
||||
return s;
|
||||
};
|
||||
|
||||
String.prototype.rpad = function(len, chr) {
|
||||
if (!len) return this;
|
||||
if (chr === undefined) chr = ' ';
|
||||
var s = this+'', need = len - s.length;
|
||||
if (need > 0) s += new Array(need+1).join(chr);
|
||||
return s;
|
||||
};
|
||||
|
||||
const mpatt = [ '-?\\d{1,3}', 'P[A-I]\\d+', 'P\\d_\\d+', 'Pin[A-Z]\\d\\b' ],
|
||||
definePatt = new RegExp(`^\\s*(//)?#define\\s+[A-Z_][A-Z0-9_]+\\s+(${mpatt[0]}|${mpatt[1]}|${mpatt[2]}|${mpatt[3]})\\s*(//.*)?$`, 'gm'),
|
||||
ppad = [ 3, 4, 5, 5 ],
|
||||
col_comment = 50,
|
||||
col_value_rj = col_comment - 3;
|
||||
|
||||
var mexpr = [];
|
||||
for (let m of mpatt) mexpr.push(new RegExp('^' + m + '$'));
|
||||
|
||||
const argv = process.argv.slice(2), argc = argv.length;
|
||||
|
||||
var src_file = 0, src_name = 'STDIN', dst_file, do_log = false;
|
||||
if (argc > 0) {
|
||||
let ind = 0;
|
||||
if (argv[0] == '-v') { do_log = true; ind++; }
|
||||
dst_file = src_file = src_name = argv[ind++];
|
||||
if (ind < argc) dst_file = argv[ind];
|
||||
}
|
||||
|
||||
// Read from file or STDIN until it terminates
|
||||
const filtered = process_text(fs.readFileSync(src_file).toString());
|
||||
if (dst_file)
|
||||
fs.writeFileSync(dst_file, filtered);
|
||||
else
|
||||
console.log(filtered);
|
||||
|
||||
// Find the pin pattern so non-pin defines can be skipped
|
||||
function get_pin_pattern(txt) {
|
||||
var r, m = 0, match_count = [ 0, 0, 0, 0 ];
|
||||
definePatt.lastIndex = 0;
|
||||
while ((r = definePatt.exec(txt)) !== null) {
|
||||
let ind = -1;
|
||||
if (mexpr.some((p) => {
|
||||
ind++;
|
||||
const didmatch = r[2].match(p);
|
||||
return r[2].match(p);
|
||||
}) ) {
|
||||
const m = ++match_count[ind];
|
||||
if (m >= 5) {
|
||||
return { match: mpatt[ind], pad:ppad[ind] };
|
||||
}
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
function process_text(txt) {
|
||||
if (!txt.length) return '(no text)';
|
||||
const patt = get_pin_pattern(txt);
|
||||
if (!patt) return txt;
|
||||
const pindefPatt = new RegExp(`^(\\s*(//)?#define)\\s+([A-Z_][A-Z0-9_]+)\\s+(${patt.match})\\s*(//.*)?$`),
|
||||
noPinPatt = new RegExp(`^(\\s*(//)?#define)\\s+([A-Z_][A-Z0-9_]+)\\s+(-1)\\s*(//.*)?$`),
|
||||
skipPatt1 = new RegExp('^(\\s*(//)?#define)\\s+(AT90USB|USBCON|(BOARD|DAC|FLASH|HAS|IS|USE)_.+|.+_(ADDRESS|AVAILABLE|BAUDRATE|CLOCK|CONNECTION|DEFAULT|FREQ|ITEM|MODULE|NAME|ONLY|PERIOD|RANGE|RATE|SERIAL|SIZE|SPI|STATE|STEP|TIMER))\\s+(.+)\\s*(//.*)?$'),
|
||||
skipPatt2 = new RegExp('^(\\s*(//)?#define)\\s+([A-Z_][A-Z0-9_]+)\\s+(0x[0-9A-Fa-f]+|\d+|.+[a-z].+)\\s*(//.*)?$'),
|
||||
aliasPatt = new RegExp('^(\\s*(//)?#define)\\s+([A-Z_][A-Z0-9_]+)\\s+([A-Z_][A-Z0-9_()]+)\\s*(//.*)?$'),
|
||||
switchPatt = new RegExp('^(\\s*(//)?#define)\\s+([A-Z_][A-Z0-9_]+)\\s*(//.*)?$'),
|
||||
undefPatt = new RegExp('^(\\s*(//)?#undef)\\s+([A-Z_][A-Z0-9_]+)\\s*(//.*)?$'),
|
||||
defPatt = new RegExp('^(\\s*(//)?#define)\\s+([A-Z_][A-Z0-9_]+)\\s+([-_\\w]+)\\s*(//.*)?$'),
|
||||
condPatt = new RegExp('^(\\s*(//)?#(if|ifn?def|else|elif)(\\s+\\S+)*)\\s+(//.*)$'),
|
||||
commPatt = new RegExp('^\\s{20,}(//.*)?$');
|
||||
const col_value_lj = col_comment - patt.pad - 2;
|
||||
var r, out = '', check_comment_next = false;
|
||||
txt.split('\n').forEach((line) => {
|
||||
if (check_comment_next)
|
||||
check_comment_next = ((r = commPatt.exec(line)) !== null);
|
||||
|
||||
if (check_comment_next)
|
||||
// Comments in column 45
|
||||
line = ''.rpad(col_comment) + r[1];
|
||||
|
||||
else if (skipPatt1.exec(line) !== null) {
|
||||
//
|
||||
// #define SKIP_ME
|
||||
//
|
||||
if (do_log) console.log("skip:", line);
|
||||
}
|
||||
else if ((r = pindefPatt.exec(line)) !== null) {
|
||||
//
|
||||
// #define MY_PIN [pin]
|
||||
//
|
||||
if (do_log) console.log("pin:", line);
|
||||
const pinnum = r[4].charAt(0) == 'P' ? r[4] : r[4].lpad(patt.pad);
|
||||
line = r[1] + ' ' + r[3];
|
||||
line = line.rpad(col_value_lj) + pinnum;
|
||||
if (r[5]) line = line.rpad(col_comment) + r[5];
|
||||
}
|
||||
else if ((r = noPinPatt.exec(line)) !== null) {
|
||||
//
|
||||
// #define MY_PIN -1
|
||||
//
|
||||
if (do_log) console.log("pin -1:", line);
|
||||
line = r[1] + ' ' + r[3];
|
||||
line = line.rpad(col_value_lj) + '-1';
|
||||
if (r[5]) line = line.rpad(col_comment) + r[5];
|
||||
}
|
||||
else if (skipPatt2.exec(line) !== null) {
|
||||
//
|
||||
// #define SKIP_ME
|
||||
//
|
||||
if (do_log) console.log("skip:", line);
|
||||
}
|
||||
else if ((r = aliasPatt.exec(line)) !== null) {
|
||||
//
|
||||
// #define ALIAS OTHER
|
||||
//
|
||||
if (do_log) console.log("alias:", line);
|
||||
line = r[1] + ' ' + r[3];
|
||||
line += r[4].lpad(col_value_rj + 1 - line.length);
|
||||
if (r[5]) line = line.rpad(col_comment) + r[5];
|
||||
}
|
||||
else if ((r = switchPatt.exec(line)) !== null) {
|
||||
//
|
||||
// #define SWITCH
|
||||
//
|
||||
if (do_log) console.log("switch:", line);
|
||||
line = r[1] + ' ' + r[3];
|
||||
if (r[4]) line = line.rpad(col_comment) + r[4];
|
||||
check_comment_next = true;
|
||||
}
|
||||
else if ((r = defPatt.exec(line)) !== null) {
|
||||
//
|
||||
// #define ...
|
||||
//
|
||||
if (do_log) console.log("def:", line);
|
||||
line = r[1] + ' ' + r[3] + ' ';
|
||||
line += r[4].lpad(col_value_rj + 1 - line.length);
|
||||
if (r[5]) line = line.rpad(col_comment - 1) + ' ' + r[5];
|
||||
}
|
||||
else if ((r = undefPatt.exec(line)) !== null) {
|
||||
//
|
||||
// #undef ...
|
||||
//
|
||||
if (do_log) console.log("undef:", line);
|
||||
line = r[1] + ' ' + r[3];
|
||||
if (r[4]) line = line.rpad(col_comment) + r[4];
|
||||
}
|
||||
else if ((r = condPatt.exec(line)) !== null) {
|
||||
//
|
||||
// #if ...
|
||||
//
|
||||
if (do_log) console.log("cond:", line);
|
||||
line = r[1].rpad(col_comment) + r[5];
|
||||
check_comment_next = true;
|
||||
}
|
||||
out += line + '\n';
|
||||
});
|
||||
return out.replace(/\n\n+/g, '\n\n').replace(/\n\n$/g, '\n');
|
||||
}
|
||||
342
hannoprint/Marlin-2.1.2.1/buildroot/share/scripts/upload.py
Normal file
342
hannoprint/Marlin-2.1.2.1/buildroot/share/scripts/upload.py
Normal file
@@ -0,0 +1,342 @@
|
||||
import argparse
|
||||
import sys
|
||||
import os
|
||||
import time
|
||||
import random
|
||||
import serial
|
||||
|
||||
Import("env")
|
||||
|
||||
# Needed (only) for compression, but there are problems with pip install heatshrink
|
||||
#try:
|
||||
# import heatshrink
|
||||
#except ImportError:
|
||||
# # Install heatshrink
|
||||
# print("Installing 'heatshrink' python module...")
|
||||
# env.Execute(env.subst("$PYTHONEXE -m pip install heatshrink"))
|
||||
#
|
||||
# Not tested: If it's safe to install python libraries in PIO python try:
|
||||
# env.Execute(env.subst("$PYTHONEXE -m pip install https://github.com/p3p/pyheatshrink/releases/download/0.3.3/pyheatshrink-pip.zip"))
|
||||
|
||||
import MarlinBinaryProtocol
|
||||
|
||||
#-----------------#
|
||||
# Upload Callback #
|
||||
#-----------------#
|
||||
def Upload(source, target, env):
|
||||
|
||||
#-------#
|
||||
# Debug #
|
||||
#-------#
|
||||
Debug = False # Set to True to enable script debug
|
||||
def debugPrint(data):
|
||||
if Debug: print(f"[Debug]: {data}")
|
||||
|
||||
#------------------#
|
||||
# Marlin functions #
|
||||
#------------------#
|
||||
def _GetMarlinEnv(marlinEnv, feature):
|
||||
if not marlinEnv: return None
|
||||
return marlinEnv[feature] if feature in marlinEnv else None
|
||||
|
||||
#----------------#
|
||||
# Port functions #
|
||||
#----------------#
|
||||
def _GetUploadPort(env):
|
||||
debugPrint('Autodetecting upload port...')
|
||||
env.AutodetectUploadPort(env)
|
||||
portName = env.subst('$UPLOAD_PORT')
|
||||
if not portName:
|
||||
raise Exception('Error detecting the upload port.')
|
||||
debugPrint('OK')
|
||||
return portName
|
||||
|
||||
#-------------------------#
|
||||
# Simple serial functions #
|
||||
#-------------------------#
|
||||
def _OpenPort():
|
||||
# Open serial port
|
||||
if port.is_open: return
|
||||
debugPrint('Opening upload port...')
|
||||
port.open()
|
||||
port.reset_input_buffer()
|
||||
debugPrint('OK')
|
||||
|
||||
def _ClosePort():
|
||||
# Open serial port
|
||||
if port is None: return
|
||||
if not port.is_open: return
|
||||
debugPrint('Closing upload port...')
|
||||
port.close()
|
||||
debugPrint('OK')
|
||||
|
||||
def _Send(data):
|
||||
debugPrint(f'>> {data}')
|
||||
strdata = bytearray(data, 'utf8') + b'\n'
|
||||
port.write(strdata)
|
||||
time.sleep(0.010)
|
||||
|
||||
def _Recv():
|
||||
clean_responses = []
|
||||
responses = port.readlines()
|
||||
for Resp in responses:
|
||||
# Suppress invalid chars (coming from debug info)
|
||||
try:
|
||||
clean_response = Resp.decode('utf8').rstrip().lstrip()
|
||||
clean_responses.append(clean_response)
|
||||
debugPrint(f'<< {clean_response}')
|
||||
except:
|
||||
pass
|
||||
return clean_responses
|
||||
|
||||
#------------------#
|
||||
# SDCard functions #
|
||||
#------------------#
|
||||
def _CheckSDCard():
|
||||
debugPrint('Checking SD card...')
|
||||
_Send('M21')
|
||||
Responses = _Recv()
|
||||
if len(Responses) < 1 or not any('SD card ok' in r for r in Responses):
|
||||
raise Exception('Error accessing SD card')
|
||||
debugPrint('SD Card OK')
|
||||
return True
|
||||
|
||||
#----------------#
|
||||
# File functions #
|
||||
#----------------#
|
||||
def _GetFirmwareFiles(UseLongFilenames):
|
||||
debugPrint('Get firmware files...')
|
||||
_Send(f"M20 F{'L' if UseLongFilenames else ''}")
|
||||
Responses = _Recv()
|
||||
if len(Responses) < 3 or not any('file list' in r for r in Responses):
|
||||
raise Exception('Error getting firmware files')
|
||||
debugPrint('OK')
|
||||
return Responses
|
||||
|
||||
def _FilterFirmwareFiles(FirmwareList, UseLongFilenames):
|
||||
Firmwares = []
|
||||
for FWFile in FirmwareList:
|
||||
# For long filenames take the 3rd column of the firmwares list
|
||||
if UseLongFilenames:
|
||||
Space = 0
|
||||
Space = FWFile.find(' ')
|
||||
if Space >= 0: Space = FWFile.find(' ', Space + 1)
|
||||
if Space >= 0: FWFile = FWFile[Space + 1:]
|
||||
if not '/' in FWFile and '.BIN' in FWFile.upper():
|
||||
Firmwares.append(FWFile[:FWFile.upper().index('.BIN') + 4])
|
||||
return Firmwares
|
||||
|
||||
def _RemoveFirmwareFile(FirmwareFile):
|
||||
_Send(f'M30 /{FirmwareFile}')
|
||||
Responses = _Recv()
|
||||
Removed = len(Responses) >= 1 and any('File deleted' in r for r in Responses)
|
||||
if not Removed:
|
||||
raise Exception(f"Firmware file '{FirmwareFile}' not removed")
|
||||
return Removed
|
||||
|
||||
def _RollbackUpload(FirmwareFile):
|
||||
if not rollback: return
|
||||
print(f"Rollback: trying to delete firmware '{FirmwareFile}'...")
|
||||
_OpenPort()
|
||||
# Wait for SD card release
|
||||
time.sleep(1)
|
||||
# Remount SD card
|
||||
_CheckSDCard()
|
||||
print(' OK' if _RemoveFirmwareFile(FirmwareFile) else ' Error!')
|
||||
_ClosePort()
|
||||
|
||||
|
||||
#---------------------#
|
||||
# Callback Entrypoint #
|
||||
#---------------------#
|
||||
port = None
|
||||
protocol = None
|
||||
filetransfer = None
|
||||
rollback = False
|
||||
|
||||
# Get Marlin evironment vars
|
||||
MarlinEnv = env['MARLIN_FEATURES']
|
||||
marlin_pioenv = _GetMarlinEnv(MarlinEnv, 'PIOENV')
|
||||
marlin_motherboard = _GetMarlinEnv(MarlinEnv, 'MOTHERBOARD')
|
||||
marlin_board_info_name = _GetMarlinEnv(MarlinEnv, 'BOARD_INFO_NAME')
|
||||
marlin_board_custom_build_flags = _GetMarlinEnv(MarlinEnv, 'BOARD_CUSTOM_BUILD_FLAGS')
|
||||
marlin_firmware_bin = _GetMarlinEnv(MarlinEnv, 'FIRMWARE_BIN')
|
||||
marlin_long_filename_host_support = _GetMarlinEnv(MarlinEnv, 'LONG_FILENAME_HOST_SUPPORT') is not None
|
||||
marlin_longname_write = _GetMarlinEnv(MarlinEnv, 'LONG_FILENAME_WRITE_SUPPORT') is not None
|
||||
marlin_custom_firmware_upload = _GetMarlinEnv(MarlinEnv, 'CUSTOM_FIRMWARE_UPLOAD') is not None
|
||||
marlin_short_build_version = _GetMarlinEnv(MarlinEnv, 'SHORT_BUILD_VERSION')
|
||||
marlin_string_config_h_author = _GetMarlinEnv(MarlinEnv, 'STRING_CONFIG_H_AUTHOR')
|
||||
|
||||
# Get firmware upload params
|
||||
upload_firmware_source_name = str(source[0]) # Source firmware filename
|
||||
upload_speed = env['UPLOAD_SPEED'] if 'UPLOAD_SPEED' in env else 115200
|
||||
# baud rate of serial connection
|
||||
upload_port = _GetUploadPort(env) # Serial port to use
|
||||
|
||||
# Set local upload params
|
||||
upload_firmware_target_name = os.path.basename(upload_firmware_source_name)
|
||||
# Target firmware filename
|
||||
upload_timeout = 1000 # Communication timout, lossy/slow connections need higher values
|
||||
upload_blocksize = 512 # Transfer block size. 512 = Autodetect
|
||||
upload_compression = True # Enable compression
|
||||
upload_error_ratio = 0 # Simulated corruption ratio
|
||||
upload_test = False # Benchmark the serial link without storing the file
|
||||
upload_reset = True # Trigger a soft reset for firmware update after the upload
|
||||
|
||||
# Set local upload params based on board type to change script behavior
|
||||
# "upload_delete_old_bins": delete all *.bin files in the root of SD Card
|
||||
upload_delete_old_bins = marlin_motherboard in ['BOARD_CREALITY_V4', 'BOARD_CREALITY_V4210', 'BOARD_CREALITY_V422', 'BOARD_CREALITY_V423',
|
||||
'BOARD_CREALITY_V427', 'BOARD_CREALITY_V431', 'BOARD_CREALITY_V452', 'BOARD_CREALITY_V453',
|
||||
'BOARD_CREALITY_V24S1']
|
||||
# "upload_random_name": generate a random 8.3 firmware filename to upload
|
||||
upload_random_filename = upload_delete_old_bins and not marlin_long_filename_host_support
|
||||
|
||||
try:
|
||||
|
||||
# Start upload job
|
||||
print(f"Uploading firmware '{os.path.basename(upload_firmware_target_name)}' to '{marlin_motherboard}' via '{upload_port}'")
|
||||
|
||||
# Dump some debug info
|
||||
if Debug:
|
||||
print('Upload using:')
|
||||
print('---- Marlin -----------------------------------')
|
||||
print(f' PIOENV : {marlin_pioenv}')
|
||||
print(f' SHORT_BUILD_VERSION : {marlin_short_build_version}')
|
||||
print(f' STRING_CONFIG_H_AUTHOR : {marlin_string_config_h_author}')
|
||||
print(f' MOTHERBOARD : {marlin_motherboard}')
|
||||
print(f' BOARD_INFO_NAME : {marlin_board_info_name}')
|
||||
print(f' CUSTOM_BUILD_FLAGS : {marlin_board_custom_build_flags}')
|
||||
print(f' FIRMWARE_BIN : {marlin_firmware_bin}')
|
||||
print(f' LONG_FILENAME_HOST_SUPPORT : {marlin_long_filename_host_support}')
|
||||
print(f' LONG_FILENAME_WRITE_SUPPORT : {marlin_longname_write}')
|
||||
print(f' CUSTOM_FIRMWARE_UPLOAD : {marlin_custom_firmware_upload}')
|
||||
print('---- Upload parameters ------------------------')
|
||||
print(f' Source : {upload_firmware_source_name}')
|
||||
print(f' Target : {upload_firmware_target_name}')
|
||||
print(f' Port : {upload_port} @ {upload_speed} baudrate')
|
||||
print(f' Timeout : {upload_timeout}')
|
||||
print(f' Block size : {upload_blocksize}')
|
||||
print(f' Compression : {upload_compression}')
|
||||
print(f' Error ratio : {upload_error_ratio}')
|
||||
print(f' Test : {upload_test}')
|
||||
print(f' Reset : {upload_reset}')
|
||||
print('-----------------------------------------------')
|
||||
|
||||
# Custom implementations based on board parameters
|
||||
# Generate a new 8.3 random filename
|
||||
if upload_random_filename:
|
||||
upload_firmware_target_name = f"fw-{''.join(random.choices('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', k=5))}.BIN"
|
||||
print(f"Board {marlin_motherboard}: Overriding firmware filename to '{upload_firmware_target_name}'")
|
||||
|
||||
# Delete all *.bin files on the root of SD Card (if flagged)
|
||||
if upload_delete_old_bins:
|
||||
# CUSTOM_FIRMWARE_UPLOAD is needed for this feature
|
||||
if not marlin_custom_firmware_upload:
|
||||
raise Exception(f"CUSTOM_FIRMWARE_UPLOAD must be enabled in 'Configuration_adv.h' for '{marlin_motherboard}'")
|
||||
|
||||
# Init & Open serial port
|
||||
port = serial.Serial(upload_port, baudrate = upload_speed, write_timeout = 0, timeout = 0.1)
|
||||
_OpenPort()
|
||||
|
||||
# Check SD card status
|
||||
_CheckSDCard()
|
||||
|
||||
# Get firmware files
|
||||
FirmwareFiles = _GetFirmwareFiles(marlin_long_filename_host_support)
|
||||
if Debug:
|
||||
for FirmwareFile in FirmwareFiles:
|
||||
print(f'Found: {FirmwareFile}')
|
||||
|
||||
# Get all 1st level firmware files (to remove)
|
||||
OldFirmwareFiles = _FilterFirmwareFiles(FirmwareFiles[1:len(FirmwareFiles)-2], marlin_long_filename_host_support) # Skip header and footers of list
|
||||
if len(OldFirmwareFiles) == 0:
|
||||
print('No old firmware files to delete')
|
||||
else:
|
||||
print(f"Remove {len(OldFirmwareFiles)} old firmware file{'s' if len(OldFirmwareFiles) != 1 else ''}:")
|
||||
for OldFirmwareFile in OldFirmwareFiles:
|
||||
print(f" -Removing- '{OldFirmwareFile}'...")
|
||||
print(' OK' if _RemoveFirmwareFile(OldFirmwareFile) else ' Error!')
|
||||
|
||||
# Close serial
|
||||
_ClosePort()
|
||||
|
||||
# Cleanup completed
|
||||
debugPrint('Cleanup completed')
|
||||
|
||||
# WARNING! The serial port must be closed here because the serial transfer that follow needs it!
|
||||
|
||||
# Upload firmware file
|
||||
debugPrint(f"Copy '{upload_firmware_source_name}' --> '{upload_firmware_target_name}'")
|
||||
protocol = MarlinBinaryProtocol.Protocol(upload_port, upload_speed, upload_blocksize, float(upload_error_ratio), int(upload_timeout))
|
||||
#echologger = MarlinBinaryProtocol.EchoProtocol(protocol)
|
||||
protocol.connect()
|
||||
# Mark the rollback (delete broken transfer) from this point on
|
||||
rollback = True
|
||||
filetransfer = MarlinBinaryProtocol.FileTransferProtocol(protocol)
|
||||
transferOK = filetransfer.copy(upload_firmware_source_name, upload_firmware_target_name, upload_compression, upload_test)
|
||||
protocol.disconnect()
|
||||
|
||||
# Notify upload completed
|
||||
protocol.send_ascii('M117 Firmware uploaded' if transferOK else 'M117 Firmware upload failed')
|
||||
|
||||
# Remount SD card
|
||||
print('Wait for SD card release...')
|
||||
time.sleep(1)
|
||||
print('Remount SD card')
|
||||
protocol.send_ascii('M21')
|
||||
|
||||
# Transfer failed?
|
||||
if not transferOK:
|
||||
protocol.shutdown()
|
||||
_RollbackUpload(upload_firmware_target_name)
|
||||
else:
|
||||
# Trigger firmware update
|
||||
if upload_reset:
|
||||
print('Trigger firmware update...')
|
||||
protocol.send_ascii('M997', True)
|
||||
protocol.shutdown()
|
||||
|
||||
print('Firmware update completed' if transferOK else 'Firmware update failed')
|
||||
return 0 if transferOK else -1
|
||||
|
||||
except KeyboardInterrupt:
|
||||
print('Aborted by user')
|
||||
if filetransfer: filetransfer.abort()
|
||||
if protocol:
|
||||
protocol.disconnect()
|
||||
protocol.shutdown()
|
||||
_RollbackUpload(upload_firmware_target_name)
|
||||
_ClosePort()
|
||||
raise
|
||||
|
||||
except serial.SerialException as se:
|
||||
# This exception is raised only for send_ascii data (not for binary transfer)
|
||||
print(f'Serial excepion: {se}, transfer aborted')
|
||||
if protocol:
|
||||
protocol.disconnect()
|
||||
protocol.shutdown()
|
||||
_RollbackUpload(upload_firmware_target_name)
|
||||
_ClosePort()
|
||||
raise Exception(se)
|
||||
|
||||
except MarlinBinaryProtocol.FatalError:
|
||||
print('Too many retries, transfer aborted')
|
||||
if protocol:
|
||||
protocol.disconnect()
|
||||
protocol.shutdown()
|
||||
_RollbackUpload(upload_firmware_target_name)
|
||||
_ClosePort()
|
||||
raise
|
||||
|
||||
except Exception as ex:
|
||||
print(f"\nException: {ex}, transfer aborted")
|
||||
if protocol:
|
||||
protocol.disconnect()
|
||||
protocol.shutdown()
|
||||
_RollbackUpload(upload_firmware_target_name)
|
||||
_ClosePort()
|
||||
print('Firmware not updated')
|
||||
raise
|
||||
|
||||
# Attach custom upload callback
|
||||
env.Replace(UPLOADCMD=Upload)
|
||||
Reference in New Issue
Block a user