I just saw this on hack a day – someone is working on a python library which implements the ezcad USB protocol!
https://www.bryce.pw/engraver.html
Now I am really tempted to buy a low-cost laser (and build my own enclosure) or buy a non-safety interlock one and add interlocks
thats neat , lightburn just added support for ezcad galvos too,
This looks quite good. Seems like it would have interlocks. (sorry, can only generate affiliate links from the app)
https://a.aliexpress.com/_mqYurT2
I have found that most of these machines from China do not have safety interlocks. They allow you to run the laser with the door open, so it’s up to the operator to be safe. For my contract manufacturer, that’s a non-starter. They need a class 1 laser system. Since I don’t see any mention of class 1, FDA, and it ships with goggles, I would guess that this is another product that is almost safe 
I have been holding off on this purchase, but it’s still on the list! The vendor doing the aluminum enclosure is also going to laser engrave the top. For a total cost of $2.70 including the extrusion, sand blasting, anodizing, cut to length, and laser engraving, I have zero reasons not to have them laser engrave the top. So, I only need to mark the bottom.
I am still leaning towards the LaserGear BOQX. It’s a Chinese laser system with Ezcad, so it’s very expensive for 20W MOPA. However, it is class 1 with US-based support to make my CM happy.
These electric or pneumatic (depending on the model) style of oscillating needle engravers are also interesting. No laser to worry about but you would want your fingers clear. Much more realistic for a small manufacturer to purchase/use themselves maybe, for slightly less resolution. JMZQ-170/JMZD-170 Pneumatic Electric Marking Machine 300w Desktop Car Identification Plate Metal Parts Engraving Machine
https://a.aliexpress.com/_mqFto0s
just installing new laser in the garage, its a little bigger than what is needed for marking. but once we get it up and running happy to give feedback/answer questions on it. its 1 kW fibre with 1300x900mm cutting bed and will cut 8mm carbon steel.
chinese laser as most of them are and its pretty well made, we’ve bought from this oem before and they supply places like full spectrum and boss laser (who claim they engineered and designed it in the usa interestingly enough, they did add some go faster stripes to theirs to be fair )
Other than the chiller/cooler what supporting services/infrastructure does it need? Please let us know what the kerf on 8mm steel looks like!
yes it is a chiller, so that plus voltage regulator , 220vac 1ph (claimed 60a but it is not, will update when do the proper numbers), nitrogen , oxygen/air supply, largeish extraction fan which it comes with all the things beyond the tanks for the assist gases
it will run off 3 ph 380vac too. and i will post pics of the kerf , hopefully will get it up on saturday
A really bigger one than ordinary. How does it work. I got a new machine from China too and it works well
Thanks for information
Looks like OMtech now sells an enclosed fiber laser – and their recent models are Lightburn supported. Very very tempting.
I ended up purchasing the Tykma Electrox LaserGear BOQX for the Joulescope JS220 backside marking. The total price was $18,700 USD including the fume extractor. It’s definitely pricier than other options for the capabilities, but it has a class 1 enclosure my CM trusts with a company we trust. My CM is happy, it is working well, and I’m happy.
I managed to integrate the MiniLase Pro SE software (rebranded EZCAD2) into my python-based final test station. The station performs some testing on the unit and reads off the device info before firing up the laser. The test station runs a python socket server process to communicate the data between the test station python (based upon pytation) and the laser software.
The test station publishes the serial number and manufacturing date to the socket server. The EZCAD2 software has the option to query values from a socket server, and it pulls down these values for each run. I also could not figure out how to fully automate the end time. Pywinauto seemed to work initially but then became unreliable. Not sure why. So, it’s on a fixed delay. A bit hacked together, but it’s working well enough so far.
See it in action:
And here is the python code implemented as a pytation device:
# Copyright 2022 Jetperch LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from pytation import Context
import asyncio
import logging
import os
import pywinauto
import socket
import sys
import threading
import time
HOST = '127.0.0.1'
PORT = 1000
EXE = r'C:\Program Files (x86)\Minilase Pro SE\Minilase Pro SE.exe'
PSE = r'C:\repos\template.pse'
class Boqx:
"""The TYKMA Electrox LaserGear BOQX laser.
This laser used the MiniLase Pro SE software (rebranded ezcad2).
"""
NAME = f'BOQX laser'
def __init__(self):
self.parameter = {
'serial_number': 'xxxxxx',
'production_date': 'xxxx-xx-xx'
}
self._port = PORT
self._thread = None
self._log = logging.getLogger(__name__)
self._asyncio_loop = None
self._app = None
self._win = None
def setup(self, context: Context):
if context is None:
exe = EXE
pse = PSE
else:
exe = context.config.get('exe', EXE)
pse = context.config.get('pse', PSE)
appname = 'Minilase Pro SE - ' + os.path.splitext(os.path.basename(pse))[0]
self._app = pywinauto.Application().start(f'{exe} {pse}')
self._win = self._app[appname]
# self._win.Properties.print_control_identifiers()
# self._win.menu_items()
self._win.minimize()
self.server_start()
def server_start(self):
self._thread = threading.Thread(target=self._run_thread)
self._thread.start()
def server_stop(self):
client('!stop:')
self._thread.join()
def restore(self):
self.parameter['serial_number'] = 'xxxxxx'
self.parameter['production_date'] = 'xxxx-xx-xx'
def teardown(self):
self._win.menu_select("File->Exit")
time.sleep(0.1)
dlg = self._app.top_window()
dlg.No.click()
self.server_stop()
def mark(self, timeout_s=None):
timeout_s = 60.0 if timeout_s is None else float(timeout_s)
self._win.send_keystrokes('{F2}')
t_start = time.time()
print('mark: wait start')
while (time.time() - t_start) < timeout_s:
time.sleep(0.5)
print('mark: timeout')
async def _handle_client(self, reader, writer):
print('client: connected')
try:
while True:
cmd = await reader.readuntil(b':')
cmd = cmd.decode('utf-8')[:-1]
print(f'command: {cmd}')
if cmd in self.parameter:
rsp = self.parameter[cmd] + '\x00'
elif cmd == '!update':
line = await reader.readuntil(b':')
line = line.decode('utf-8')[:-1]
print(f' {line}')
for key, value in [x.split('=') for x in line.split(',')]:
if key in self.parameter:
self.parameter[key] = value
else:
self._log.warning(f'unsupported key: {key}')
rsp = 'OK\n'
elif cmd == '!stop':
self._asyncio_loop.stop()
rsp = 'OK\n'
else:
self._log.warning(f'Unsupported command: {cmd}')
rsp = 'ERROR\n'
rsp = rsp.encode('utf-8')
writer.write(rsp)
await writer.drain()
except asyncio.IncompleteReadError:
print('IncompleteReadError')
print('client: disconnect')
writer.close()
def _run_thread(self):
loop = asyncio.new_event_loop()
self._asyncio_loop = loop
asyncio.set_event_loop(loop)
coro = asyncio.start_server(self._handle_client, HOST, self._port)
server = loop.run_until_complete(coro)
# Serve requests until Ctrl+C is pressed
print('Serving on {}'.format(server.sockets[0].getsockname()))
try:
loop.run_forever()
except KeyboardInterrupt:
pass
# Close the server
server.close()
loop.run_until_complete(server.wait_closed())
loop.close()
def client(cmd):
if isinstance(cmd, str):
cmd = cmd.encode('utf-8')
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.connect((HOST, PORT))
s.sendall(cmd)
rsp = s.recv(4096)
rsp = rsp.decode('utf-8')
print(rsp)
s.close()
lightburn supports a lot of these devices now after the protocol was RE’d their is a python repo with the RE work, though there might be some that the lightburn folks did that didn’t go back in to it (speculation)
I am not sure where Balor is with this laser. I really don’t need LightBurn as I would rather just generate the SVG from my python code and be done with it. I ran out of time, and I really did not want to risk damaging anything. So, rebranded EZCAD2 it is for now. EZCAD2 is annoying for creating the image to engrave, but at least it seems to be reliable on the manufacturing line so far.
Neat!
And a minute after I saw that video, this ad popped up in my FB timeline: ComMarker B4 Small Fiber Laser Engraver: 10X Faster & Deeper by ComMarker — Kickstarter
It feels so dangerous and yet so tempting…
This looks like magic. Super cool!
yep agreed, ezcad2 is a pita and its EOL’d but what works, works! glad its going for you.
Well, I’ve purchased a OmTech 50w enclosed laser. Should be here in about a week. There is Lightroom support, which I will def be using over EzCad. I’ll report back once it arrives and once I start playing with it.
I think it will be powerful enough to cut stainless stencils (with bad edge quality on the apertures). I will stick with OSHStencil and others for production stencils, but when I need to stencil just a few boards – or when I want to experiment with different apertures to improve reflow yield, could be handy to have in house.
Like Matt, I’ll be using it for enclosure engraving for upcoming products (USB Hub, cameras, etc).
i cut stencils on my 60w mopa, took me a while to tune it in without warping the metal
I just received my 50W Cloudray Fiber laser
it has an enclosure, but as expected no interlock. I will probably make some automation changes to it anyway so adding an interlock would be trivial.
Thankfully my jurisdiction allows me to “fabricate machinery for internal use” and only certify it when it has to be operated by an employee. So until my little shop grows i can work with it.