fixed app to use new thorlabs driver
This commit is contained in:
Thomas Ales [M S E]
@@ -0,0 +1,144 @@
|
||||
{
|
||||
"scan_info": {
|
||||
"friendly_name": "stest",
|
||||
"waveform_prefix": "aaa",
|
||||
"data_directory": "/opt/scanengine-3",
|
||||
"timestamp": "2026-02-09T15:57:49.753094",
|
||||
"scan_finished": true,
|
||||
"completion_timestamp": "2026-02-09T15:57:58.301940"
|
||||
},
|
||||
"scan_parameters": {
|
||||
"number_of_angles": 4,
|
||||
"row_spacing_mm": 0.5,
|
||||
"scan_type": "standalone"
|
||||
},
|
||||
"scan_area": {
|
||||
"x_start_mm": 48.5,
|
||||
"x_delta_mm": 15.83,
|
||||
"y_start_mm": 42.17,
|
||||
"y_delta_mm": -15.67,
|
||||
"sample_size": "1.25\""
|
||||
},
|
||||
"scan_boxes": [
|
||||
{
|
||||
"angle_index": 0,
|
||||
"angle_degrees": 0.0,
|
||||
"start": [
|
||||
48.5,
|
||||
26.5
|
||||
],
|
||||
"end": [
|
||||
64.33,
|
||||
42.17
|
||||
],
|
||||
"original_corners": [
|
||||
[
|
||||
48.5,
|
||||
42.17
|
||||
],
|
||||
[
|
||||
64.33,
|
||||
42.17
|
||||
],
|
||||
[
|
||||
64.33,
|
||||
26.5
|
||||
],
|
||||
[
|
||||
48.5,
|
||||
26.5
|
||||
]
|
||||
]
|
||||
},
|
||||
{
|
||||
"angle_index": 1,
|
||||
"angle_degrees": 45.0,
|
||||
"start": [
|
||||
45.3339,
|
||||
24.3934
|
||||
],
|
||||
"end": [
|
||||
67.6077,
|
||||
46.6673
|
||||
],
|
||||
"original_corners": [
|
||||
[
|
||||
45.3339,
|
||||
35.4738
|
||||
],
|
||||
[
|
||||
56.5274,
|
||||
46.6673
|
||||
],
|
||||
[
|
||||
67.6077,
|
||||
35.5869
|
||||
],
|
||||
[
|
||||
56.4142,
|
||||
24.3934
|
||||
]
|
||||
]
|
||||
},
|
||||
{
|
||||
"angle_index": 2,
|
||||
"angle_degrees": 90.0,
|
||||
"start": [
|
||||
47.83,
|
||||
28.5
|
||||
],
|
||||
"end": [
|
||||
63.5,
|
||||
44.33
|
||||
],
|
||||
"original_corners": [
|
||||
[
|
||||
47.83,
|
||||
28.5
|
||||
],
|
||||
[
|
||||
47.83,
|
||||
44.33
|
||||
],
|
||||
[
|
||||
63.5,
|
||||
44.33
|
||||
],
|
||||
[
|
||||
63.5,
|
||||
28.5
|
||||
]
|
||||
]
|
||||
},
|
||||
{
|
||||
"angle_index": 3,
|
||||
"angle_degrees": 135.0,
|
||||
"start": [
|
||||
43.3327,
|
||||
25.3339
|
||||
],
|
||||
"end": [
|
||||
65.6066,
|
||||
47.6077
|
||||
],
|
||||
"original_corners": [
|
||||
[
|
||||
54.5262,
|
||||
25.3339
|
||||
],
|
||||
[
|
||||
43.3327,
|
||||
36.5274
|
||||
],
|
||||
[
|
||||
54.4131,
|
||||
47.6077
|
||||
],
|
||||
[
|
||||
65.6066,
|
||||
36.4142
|
||||
]
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,144 @@
|
||||
{
|
||||
"scan_info": {
|
||||
"friendly_name": "test2",
|
||||
"waveform_prefix": "aaa",
|
||||
"data_directory": "/opt/scanengine-3",
|
||||
"timestamp": "2026-02-09T16:06:28.364606",
|
||||
"scan_finished": true,
|
||||
"completion_timestamp": "2026-02-09T16:27:37.121723"
|
||||
},
|
||||
"scan_parameters": {
|
||||
"number_of_angles": 4,
|
||||
"row_spacing_mm": 0.25,
|
||||
"scan_type": "standalone"
|
||||
},
|
||||
"scan_area": {
|
||||
"x_start_mm": 54.83,
|
||||
"x_delta_mm": 9.83,
|
||||
"y_start_mm": 43.83,
|
||||
"y_delta_mm": -9.17,
|
||||
"sample_size": "1.25\""
|
||||
},
|
||||
"scan_boxes": [
|
||||
{
|
||||
"angle_index": 0,
|
||||
"angle_degrees": 0.0,
|
||||
"start": [
|
||||
54.83,
|
||||
34.66
|
||||
],
|
||||
"end": [
|
||||
64.66,
|
||||
43.83
|
||||
],
|
||||
"original_corners": [
|
||||
[
|
||||
54.83,
|
||||
43.83
|
||||
],
|
||||
[
|
||||
64.66,
|
||||
43.83
|
||||
],
|
||||
[
|
||||
64.66,
|
||||
34.66
|
||||
],
|
||||
[
|
||||
54.83,
|
||||
34.66
|
||||
]
|
||||
]
|
||||
},
|
||||
{
|
||||
"angle_index": 1,
|
||||
"angle_degrees": 45.0,
|
||||
"start": [
|
||||
48.636,
|
||||
34.6394
|
||||
],
|
||||
"end": [
|
||||
62.0711,
|
||||
48.0744
|
||||
],
|
||||
"original_corners": [
|
||||
[
|
||||
48.636,
|
||||
41.1235
|
||||
],
|
||||
[
|
||||
55.5869,
|
||||
48.0744
|
||||
],
|
||||
[
|
||||
62.0711,
|
||||
41.5902
|
||||
],
|
||||
[
|
||||
55.1202,
|
||||
34.6394
|
||||
]
|
||||
]
|
||||
},
|
||||
{
|
||||
"angle_index": 2,
|
||||
"angle_degrees": 90.0,
|
||||
"start": [
|
||||
46.17,
|
||||
34.83
|
||||
],
|
||||
"end": [
|
||||
55.34,
|
||||
44.66
|
||||
],
|
||||
"original_corners": [
|
||||
[
|
||||
46.17,
|
||||
34.83
|
||||
],
|
||||
[
|
||||
46.17,
|
||||
44.66
|
||||
],
|
||||
[
|
||||
55.34,
|
||||
44.66
|
||||
],
|
||||
[
|
||||
55.34,
|
||||
34.83
|
||||
]
|
||||
]
|
||||
},
|
||||
{
|
||||
"angle_index": 3,
|
||||
"angle_degrees": 135.0,
|
||||
"start": [
|
||||
41.9256,
|
||||
28.636
|
||||
],
|
||||
"end": [
|
||||
55.3606,
|
||||
42.0711
|
||||
],
|
||||
"original_corners": [
|
||||
[
|
||||
48.8765,
|
||||
28.636
|
||||
],
|
||||
[
|
||||
41.9256,
|
||||
35.5869
|
||||
],
|
||||
[
|
||||
48.4098,
|
||||
42.0711
|
||||
],
|
||||
[
|
||||
55.3606,
|
||||
35.1202
|
||||
]
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
+2
-2
@@ -11,8 +11,8 @@
|
||||
},
|
||||
"scanning_stage": {
|
||||
"scan_velocity_mm_s": "200",
|
||||
"scan_acceleration_mm_s2": "500",
|
||||
"x_trigger_mode": 5,
|
||||
"scan_acceleration_mm_s2": "1500",
|
||||
"x_trigger_mode": 6,
|
||||
"y_trigger_mode": 0,
|
||||
"optical_axis_x_mm": "55",
|
||||
"optical_axis_y_mm": "37.5"
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
"""Hardware driver modules for ScanEngine-3"""
|
||||
from .bbd202 import *
|
||||
from .pybbd202 import ThorlabsServoDriver, TriggerBitsServo, AXIS_X, AXIS_Y, CONTROLLER
|
||||
from .uc480_camera import *
|
||||
from .tektronix_base import *
|
||||
from .coherent_hops_laser import *
|
||||
|
||||
-3147
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,9 @@
|
||||
"""pybbd202 - Thorlabs BBD202 servo stage driver (pyserial-based)"""
|
||||
|
||||
from .bbd20x import ThorlabsServoDriver
|
||||
from .apt_constants import TriggerBitsServo, StatusBits
|
||||
|
||||
# Axis address constants
|
||||
AXIS_X = 0x21
|
||||
AXIS_Y = 0x22
|
||||
CONTROLLER = 0x11
|
||||
@@ -0,0 +1,59 @@
|
||||
'''
|
||||
APT Constants and Registries
|
||||
Thomas Ales | Feb 2026
|
||||
'''
|
||||
from enum import IntFlag
|
||||
|
||||
class StatusBits(IntFlag):
|
||||
MOT_SB_CWHARDLIMIT = 0x01
|
||||
MOT_SB_CCWHARDLIMIT = 0x02
|
||||
MOT_SB_INMOTIONCW = 0x10
|
||||
MOT_SB_INMOTIONCCW = 0x20
|
||||
MOT_SB_HOMING = 0x200
|
||||
MOT_SB_HOMED = 0x400
|
||||
MOT_SB_TRACKING = 0x1000
|
||||
MOT_SB_SETTLED = 0x2000
|
||||
MOT_SB_POSITIONERROR = 0x4000
|
||||
MOT_SB_INSTRERROR = 0x8000
|
||||
MOT_SB_INTERLOCK = 0x10000
|
||||
MOT_SB_OVERTEMP = 0x20000
|
||||
MOT_SB_BUSVOLTFAULT = 0x40000
|
||||
MOT_SB_COMMUTATIONERROR = 0x80000
|
||||
MOT_SB_DIGIP1 = 0x100000
|
||||
MOT_SB_OVERLOAD = 0x1000000
|
||||
MOT_SB_POWEROK = 0x10000000
|
||||
MOT_SB_ERROR = 0x40000000
|
||||
MOT_SB_ENABLED = 0x80000000
|
||||
|
||||
# combined masks for checking various
|
||||
# states
|
||||
MOT_ANY_MOVE = MOT_SB_INMOTIONCW | MOT_SB_INMOTIONCCW
|
||||
MOT_ANY_ERR = (MOT_SB_OVERTEMP | MOT_SB_BUSVOLTFAULT |
|
||||
MOT_SB_COMMUTATIONERROR | MOT_SB_OVERLOAD |
|
||||
MOT_SB_ERROR | MOT_SB_INSTRERROR)
|
||||
|
||||
class TriggerBitsStepper(IntFlag):
|
||||
TRIGIN_ENABLE = 0x01,
|
||||
TRIGOUT_ENABLE = 0x02,
|
||||
TRIGOUT_MODEFOLLOW = 0x04,
|
||||
TRIGOUT_MODEMOVEEND = 0x08,
|
||||
TRIG_RELMOVE = 0x10,
|
||||
TRIG_ABSMOVE = 0x20,
|
||||
TRIG_HOMEMOVE = 0x40,
|
||||
TRIGOUT_NOTRIGIN = 0x80
|
||||
|
||||
class TriggerBitsServo(IntFlag):
|
||||
TRIGIN_HIGH = 0x01
|
||||
TRIGIN_RELMOVE = 0x02
|
||||
TRIGIN_ABSMOVE = 0x04
|
||||
TRIGIN_HOMEMOVE = 0x08
|
||||
TRIGOUT_HIGH = 0x10
|
||||
TRIGOUT_INMOTION = 0x20
|
||||
TRIGOUT_MOTIONCOMPLETE = 0x40
|
||||
TRIGOUT_MAXVELOCITY = 0x80
|
||||
|
||||
TRIGOUT_MAXV = TRIGOUT_HIGH | TRIGOUT_MAXVELOCITY
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,318 @@
|
||||
'''
|
||||
ThorLABS APT Protocol Message Registry
|
||||
Thomas Ales | Feb 2026
|
||||
Version 1
|
||||
'''
|
||||
import struct
|
||||
from .apt_constants import StatusBits as sb
|
||||
|
||||
class APTProtocol():
|
||||
ADDRESSES = { 'HOST_PC': 0x01, 'CONTROLLER': 0x11,
|
||||
'X_AXIS': 0x21, 'Y_AXIS': 0x22
|
||||
}
|
||||
|
||||
# N.B.: If the format is anything other than the following
|
||||
# two, it is considered a 'long' message. In this case
|
||||
# the format key refers only to the payload part of the
|
||||
# message.
|
||||
# BB - Short Message, Only Source/Destination
|
||||
# BBBB - Short Message, Using Parameters 1 & 2
|
||||
|
||||
# Dictionary entries MUST BE in the order they
|
||||
# appear in the thorlabs documentation, if you don't
|
||||
# the unpacking logic goes all to 💩 and 'fun' things
|
||||
# happen.
|
||||
|
||||
MSGS = {
|
||||
0x0002: {
|
||||
'name': 'MGMSG_HW_DISCONNECT',
|
||||
'format': 'BB',
|
||||
'response': None,
|
||||
'fields': ['destination', 'source'],
|
||||
'data_fields': None
|
||||
},
|
||||
0x0005: {
|
||||
'name': 'MGMSG_HW_REQ_INFO',
|
||||
'format': 'BB',
|
||||
'response': 0x0006,
|
||||
'fields': ['destination', 'source'],
|
||||
'data_fields': None
|
||||
},
|
||||
0x0006: {
|
||||
'name': 'MGMSG_HW_GET_INFO',
|
||||
'format': '<I8sH3B61xHHH',
|
||||
'response': None,
|
||||
'fields': ['destination', 'source'],
|
||||
'data_fields': ['serial', 'model', 'type',
|
||||
'fw_minor', 'fw_interim', 'fw_major',
|
||||
'hw_ver', 'mod_state', 'num_channels']
|
||||
},
|
||||
0x0011: {
|
||||
'name': 'MGMSG_HW_START_UPDATEMSGS',
|
||||
'format': 'BB',
|
||||
'response': None,
|
||||
'fields': ['destination', 'source'],
|
||||
'data_fields': None
|
||||
},
|
||||
0x0012: {
|
||||
'name': 'MGMSG_HW_STOP_UPDATEMSGS',
|
||||
'format': 'BB',
|
||||
'response': None,
|
||||
'fields': ['destination', 'source'],
|
||||
'data_fields': None
|
||||
},
|
||||
0x0060: {
|
||||
'name': 'MGMSG_RACK_REQ_BAYUSED',
|
||||
'format': 'BBBB',
|
||||
'response': 0x0061,
|
||||
'fields': ['bay_id', 'destination', 'source'],
|
||||
'data_fields': None
|
||||
},
|
||||
0x0061: {
|
||||
'name': 'MGMSG_RACK_GET_BAYUSED',
|
||||
'format': 'BBBB',
|
||||
'response': None,
|
||||
'fields': ['bay_id', 'bay_state', 'destination', 'source'],
|
||||
'data_fields': None
|
||||
},
|
||||
0x0210: {
|
||||
'name': 'MGMSG_MOD_SET_CHANENABLESTATE',
|
||||
'format': 'BBBB',
|
||||
'response': None,
|
||||
'fields': ['chan_ident', 'enable_state', 'destination', 'source'],
|
||||
'data_fields': None
|
||||
},
|
||||
0x0211: {
|
||||
'name': 'MGMSG_MOD_REQ_CHANENABLESTATE',
|
||||
'format': 'BB',
|
||||
'response': 0x0212,
|
||||
'fields': ['destination', 'source'],
|
||||
'data_fields': None
|
||||
},
|
||||
0x0212: {
|
||||
'name': 'MGMSG_MOD_GET_CHANENABLESTATE',
|
||||
'format': 'BBBB',
|
||||
'response': None,
|
||||
'fields': ['chan_ident', 'enable_state', 'destination', 'source'],
|
||||
'data_fields': None
|
||||
},
|
||||
0x0413: {
|
||||
'name': 'MGMSG_MOT_SET_VELPARAMS',
|
||||
'format': '<Hlll',
|
||||
'response': None,
|
||||
'fields': ['destination', 'source'],
|
||||
'data_fields': ['chan_ident', 'min_velocity', 'acceleration',
|
||||
'max_velocity']
|
||||
},
|
||||
0x0414: {
|
||||
'name': 'MGMSG_MOT_REQ_VELPARAMS',
|
||||
'format': 'BBBB',
|
||||
'response': 0x0415,
|
||||
'fields': ['chan_ident', 'zero_this', 'destination', 'source'],
|
||||
'data_fields': None
|
||||
},
|
||||
0x0415: {
|
||||
'name': 'MGMSG_MOT_GET_VELPARAMS',
|
||||
'format': '<Hlll',
|
||||
'response': None,
|
||||
'fields': ['destination', 'source'],
|
||||
'data_fields': ['chan_ident', 'min_velocity', 'acceleration',
|
||||
'max_velocity']
|
||||
},
|
||||
0x0443: {
|
||||
'name': 'MGMSG_MOT_MOVE_HOME',
|
||||
'format': 'BBBB',
|
||||
'response': 0x0444,
|
||||
'fields': ['chan_ident', 'destination', 'source'],
|
||||
'data_fields': None
|
||||
},
|
||||
0x0444: {
|
||||
'name': 'MGMSG_MOT_MOVE_HOMED',
|
||||
'format': 'BBBB',
|
||||
'response': None,
|
||||
'fields': ['chan_ident', 'destination', 'source'],
|
||||
'data_fields': None
|
||||
},
|
||||
0x0448: {
|
||||
'name': 'MGMSG_MOT_MOVE_RELATIVE',
|
||||
'format': '<Hl',
|
||||
'response': 0x0464,
|
||||
'fields': ['destination', 'source'],
|
||||
'data_fields': ['chan_ident', 'relative_distance']
|
||||
},
|
||||
0x0453: {
|
||||
'name': 'MGMSG_MOT_MOVE_ABSOLUTE',
|
||||
'format': '<Hl',
|
||||
'response': 0x0464,
|
||||
'fields': ['destination', 'source'],
|
||||
'data_fields': ['chan_ident', 'absolute_distance']
|
||||
},
|
||||
0x0464: {
|
||||
'name': 'MGMSG_MOT_MOVE_COMPLETED',
|
||||
'format': '<Hl2HI',
|
||||
'response': None,
|
||||
'fields': ['destination', 'source'],
|
||||
'data_fields': ['chan_ident', 'position', 'velocity',
|
||||
'motor_current', 'status_bits']
|
||||
},
|
||||
0x0490: {
|
||||
'name': 'MGMSG_MOT_REQ_USTATUSUPDATE',
|
||||
'format': 'BB',
|
||||
'response': None,
|
||||
'fields': ['destination', 'source'],
|
||||
'data_fields': None
|
||||
},
|
||||
0x0491: {
|
||||
'name': 'MGMSG_MOT_GET_USTATUSUPDATE',
|
||||
'format': '<Hl2HI',
|
||||
'response': 0x0492,
|
||||
'fields': ['destination', 'source'],
|
||||
'data_fields': ['chan_ident', 'position',
|
||||
'velocity', 'motor_current', 'status_bits']
|
||||
},
|
||||
0x0492: {
|
||||
'name': 'MGMSG_MOT_ACK_USTATUSUPDATE',
|
||||
'format': 'BB',
|
||||
'response': None,
|
||||
'fields': ['destination', 'source'],
|
||||
'data_fields': None
|
||||
},
|
||||
0x0500: {
|
||||
'name': 'MGMSG_MOT_SET_TRIGGER',
|
||||
'format': 'BBBB',
|
||||
'response': None,
|
||||
'fields': ['chan_ident', 'mode', 'destination', 'source'],
|
||||
'data_fields': None
|
||||
},
|
||||
0x0501: {
|
||||
'name': 'MGMSG_MOT_REQ_TRIGGER',
|
||||
'format': 'BBBB',
|
||||
'response': 0x0502,
|
||||
'fields': ['chan_ident', 'mode', 'destination', 'source'],
|
||||
'data_fields': None
|
||||
},
|
||||
0x0502: {
|
||||
'name': 'MGMSG_MOT_GET_TRIGGER',
|
||||
'format': 'BBBB',
|
||||
'response': None,
|
||||
'fields': ['chan_ident', 'mode', 'destination', 'source'],
|
||||
'data_fields': None
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
def __init__(self):
|
||||
pass
|
||||
|
||||
@classmethod
|
||||
def build_message(cls, msg_id, **kwargs):
|
||||
if msg_id not in APTProtocol.MSGS:
|
||||
raise ValueError(f'Unknown Message ID: {hex(msg_id)}')
|
||||
|
||||
msg_spec = APTProtocol.MSGS[msg_id]
|
||||
|
||||
for param in msg_spec['fields']:
|
||||
if param not in kwargs:
|
||||
raise ValueError(f"Missing required parameter '{param}' for {msg_spec['name']}.")
|
||||
|
||||
msg_format = msg_spec.get('format')
|
||||
|
||||
if msg_format == 'BB':
|
||||
# this is a simple source/destination command
|
||||
dest = kwargs['destination']
|
||||
src = kwargs['source']
|
||||
message = struct.pack('<HBBBB', msg_id,
|
||||
0x00, 0x00,
|
||||
dest, src)
|
||||
|
||||
elif msg_format == 'BBBB':
|
||||
# this is a source/destination plus parameters
|
||||
# fields order: [param1, param2, destination, source] or
|
||||
# [param1, destination, source] (param2 = 0)
|
||||
fields = msg_spec['fields']
|
||||
dest = kwargs['destination']
|
||||
src = kwargs['source']
|
||||
# Get param fields (everything except destination/source)
|
||||
param_fields = [f for f in fields if f not in ('destination', 'source')]
|
||||
p1 = kwargs.get(param_fields[0], 0x00) if len(param_fields) > 0 else 0x00
|
||||
p2 = kwargs.get(param_fields[1], 0x00) if len(param_fields) > 1 else 0x00
|
||||
message = struct.pack('<HBBBB', msg_id,
|
||||
p1, p2, dest, src)
|
||||
|
||||
else:
|
||||
data_fields = msg_spec.get('data_fields')
|
||||
# verify data fields are available
|
||||
if data_fields is None:
|
||||
raise ValueError("I need data for a long message!")
|
||||
|
||||
# Extract the message specific values and
|
||||
# calculate payload size
|
||||
df_values = [kwargs[field] for field in data_fields]
|
||||
data_payload = struct.pack(msg_format, *df_values)
|
||||
payload_len = len(data_payload)
|
||||
header = struct.pack('<HHBB', msg_id, payload_len,
|
||||
kwargs['destination'] | 0x80,
|
||||
kwargs['source'])
|
||||
# put message together
|
||||
message = header + data_payload
|
||||
return message
|
||||
|
||||
@classmethod
|
||||
def unpack_message(cls, bdata):
|
||||
# Get the message ID
|
||||
msg_id = struct.unpack("<H", bdata[0:2])[0]
|
||||
|
||||
# See if the message ID has been implemented
|
||||
# in the registry
|
||||
if msg_id not in APTProtocol.MSGS:
|
||||
raise ValueError(f"This op-code {msg_id} isn't in the registry!")
|
||||
|
||||
msg_spec = APTProtocol.MSGS[msg_id]
|
||||
fmt_string = msg_spec.get('format')
|
||||
# Check if it's a long message, or just a header
|
||||
if bdata[4] & 0x80:
|
||||
# this is a long message.
|
||||
payload_size = struct.unpack("<H", bdata[2:4])[0]
|
||||
src = bdata[5]
|
||||
dest = bdata[4] & 0x7F
|
||||
payload = bdata[6:6+payload_size]
|
||||
data_fields = msg_spec.get('data_fields')
|
||||
if data_fields is None:
|
||||
raise ValueError(f"No data fields have been defined for {msg_spec['name']}!")
|
||||
|
||||
unpacked_payload = struct.unpack(fmt_string, payload)
|
||||
data = {field: value for field, value in zip(data_fields,
|
||||
unpacked_payload)}
|
||||
data['destination'] = dest
|
||||
data['source'] = src
|
||||
|
||||
return msg_id, data
|
||||
|
||||
else:
|
||||
# it is a header only message
|
||||
# determine type
|
||||
dest = bdata[4]
|
||||
src = bdata[5]
|
||||
if fmt_string == 'BB':
|
||||
# simple source/dest command
|
||||
data = {'destination': dest, 'source': src}
|
||||
return msg_id, data
|
||||
|
||||
elif fmt_string == 'BBBB':
|
||||
# simple command with parameters
|
||||
# Use field names from spec
|
||||
fields = msg_spec['fields']
|
||||
param_fields = [f for f in fields if f not in ('destination', 'source')]
|
||||
data = {'destination': dest, 'source': src}
|
||||
if len(param_fields) > 0:
|
||||
data[param_fields[0]] = bdata[2]
|
||||
if len(param_fields) > 1:
|
||||
data[param_fields[1]] = bdata[3]
|
||||
return msg_id, data
|
||||
else:
|
||||
raise ValueError(f"Message format {fmt_string} isn't defined/valid!")
|
||||
|
||||
@classmethod
|
||||
def get_name(cls, msg_id):
|
||||
return cls.MSGS.get(msg_id, {}).get('name', f'UNKNOWN_{hex(msg_id)}')
|
||||
|
||||
@@ -0,0 +1,505 @@
|
||||
'''
|
||||
BBD20X Stage Driver for SRAS
|
||||
Thomas Ales | Feb 2026
|
||||
Version 2
|
||||
'''
|
||||
|
||||
import time
|
||||
from threading import Thread, Event
|
||||
from queue import Queue, Empty
|
||||
from .apt_constants import StatusBits, TriggerBitsServo
|
||||
from .apt_messages import APTProtocol
|
||||
from .serial_comms import SerialSnooper
|
||||
|
||||
|
||||
class ThorlabsServoDriver():
|
||||
# These are specific to the MLS203-1
|
||||
# change for a different application
|
||||
counts_per_mm = 20000
|
||||
accel_scaling = 13.744
|
||||
velocity_scaling = 134217.73
|
||||
|
||||
def __init__(self):
|
||||
self.am_connected = False
|
||||
self.am_enabled = [False, False]
|
||||
self.am_homed = [False, False]
|
||||
self.am_moving = [False, False]
|
||||
self.am_error = [False, False]
|
||||
self.serial_port = "/dev/ttyUSB1"
|
||||
self.serial_spd = 115200
|
||||
self.max_velocities = [100.0, 100.0] # mm/s
|
||||
self.max_accels = [500.0, 500.0] # mm/s2
|
||||
self.positions = [-1.0, -1.0]
|
||||
self.act_velocities = [-1.0, -1.0]
|
||||
self.current_demand = [0, 0]
|
||||
self.serial_snoop = None
|
||||
self.am_listening = False
|
||||
self.pending_responses = {} # msg_id -> {'event': Event, 'data': None}
|
||||
self.bays_present = [] # list of bay addresses that responded
|
||||
self._tx_queue = Queue()
|
||||
self._polling_active = False
|
||||
self._poll_interval = 0.2 # seconds between poll cycles
|
||||
|
||||
def connect(self, port=None, spd=None):
|
||||
if port is None:
|
||||
port = self.serial_port
|
||||
else:
|
||||
self.serial_port = port
|
||||
|
||||
if spd is None:
|
||||
spd = self.serial_spd
|
||||
else:
|
||||
self.serial_spd = spd
|
||||
|
||||
self.serial_snoop = SerialSnooper(port, spd)
|
||||
self.serial_snoop.start()
|
||||
self.am_listening = True
|
||||
|
||||
# Start worker threads
|
||||
self._tx_thread = Thread(target=self._tx_worker, daemon=True)
|
||||
self._tx_thread.start()
|
||||
self._rx_thread = Thread(target=self._rx_worker, daemon=True)
|
||||
self._rx_thread.start()
|
||||
self._poll_thread = Thread(target=self._poll_worker, daemon=True)
|
||||
self._poll_thread.start()
|
||||
|
||||
# Give threads time to start
|
||||
time.sleep(0.3)
|
||||
|
||||
# Query which bays are present
|
||||
self.bays_present = []
|
||||
for bay_id in range(10): # bays 0-9
|
||||
try:
|
||||
result = self.send_and_wait(0x0060, timeout=0.5,
|
||||
bay_id=bay_id,
|
||||
destination=0x11,
|
||||
source=0x01)
|
||||
if result and result.get('bay_state') == 0x01:
|
||||
bay_addr = 0x21 + bay_id
|
||||
self.bays_present.append(bay_addr)
|
||||
|
||||
except TimeoutError:
|
||||
# Bay not present or not responding
|
||||
pass
|
||||
|
||||
if not self.bays_present:
|
||||
print(" [WARN] No bays detected!")
|
||||
|
||||
self.am_connected = True
|
||||
|
||||
# ── Worker threads ───────────────────────────────────────────
|
||||
|
||||
def _tx_worker(self):
|
||||
'''Single serial writer. All outbound messages flow through
|
||||
_tx_queue so there are no write races on the serial port.'''
|
||||
while self.am_listening:
|
||||
try:
|
||||
msg = self._tx_queue.get(timeout=0.05)
|
||||
self.serial_snoop.serial_connection.write(msg)
|
||||
self.serial_snoop.serial_connection.flush()
|
||||
except Empty:
|
||||
continue
|
||||
except (OSError, TypeError):
|
||||
break
|
||||
|
||||
def _rx_worker(self):
|
||||
'''Listens for messages on the serial RX queue and dispatches them.'''
|
||||
while self.am_listening:
|
||||
try:
|
||||
_msg = self.serial_snoop.rx_msg_queue.get(timeout=0.05)
|
||||
|
||||
# Try to parse the message, skip if unknown
|
||||
try:
|
||||
_msgid, data = APTProtocol.unpack_message(_msg)
|
||||
except ValueError:
|
||||
print(f" [WARN] Unknown message: {_msg.hex()}")
|
||||
continue
|
||||
|
||||
# Check if someone is waiting for this response
|
||||
if _msgid in self.pending_responses:
|
||||
self.pending_responses[_msgid]['data'] = data
|
||||
self.pending_responses[_msgid]['event'].set()
|
||||
|
||||
# Status update → ACK via TX queue, then update state
|
||||
if _msgid == 0x0491:
|
||||
if self.am_listening:
|
||||
_ack = APTProtocol.build_message(0x0492, source=0x01,
|
||||
destination=_msg[5])
|
||||
self._tx_queue.put(_ack)
|
||||
self._update0x491(data)
|
||||
# Move completed → update state
|
||||
elif _msgid == 0x0464:
|
||||
self._update0x0464(data)
|
||||
except Empty:
|
||||
continue
|
||||
|
||||
return
|
||||
|
||||
def _poll_worker(self):
|
||||
'''Periodically sends REQ_USTATUSUPDATE (0x0490) to each bay.
|
||||
The 0x0491 responses are ACKed by _rx_worker through the
|
||||
TX queue, which keeps the controller's comms watchdog alive.'''
|
||||
while self.am_listening:
|
||||
if self._polling_active:
|
||||
for axis_addr in (self.bays_present or [0x21, 0x22]):
|
||||
if not self.am_listening:
|
||||
break
|
||||
msg = APTProtocol.build_message(0x0490, source=0x01,
|
||||
destination=axis_addr)
|
||||
self._tx_queue.put(msg)
|
||||
time.sleep(self._poll_interval)
|
||||
else:
|
||||
time.sleep(0.05)
|
||||
|
||||
# ── Polling control ──────────────────────────────────────────
|
||||
|
||||
def start_polling(self, interval=0.2):
|
||||
'''Start periodic status polling (interval in seconds).'''
|
||||
self._poll_interval = interval
|
||||
self._polling_active = True
|
||||
|
||||
def stop_polling(self):
|
||||
'''Stop periodic status polling.'''
|
||||
self._polling_active = False
|
||||
|
||||
# ── Core messaging ───────────────────────────────────────────
|
||||
|
||||
def send_and_wait(self, msg_id, timeout=10.0, retries=1, **kwargs):
|
||||
"""Send a message and wait for its expected response.
|
||||
On timeout, drains serial buffer and retries up to `retries` times."""
|
||||
msg_spec = APTProtocol.MSGS.get(msg_id)
|
||||
if not msg_spec:
|
||||
raise ValueError(f"Unknown message: {hex(msg_id)}")
|
||||
|
||||
expected = msg_spec.get('response')
|
||||
msg = APTProtocol.build_message(msg_id, **kwargs)
|
||||
|
||||
for attempt in range(1 + retries):
|
||||
# Set up listener before sending
|
||||
if expected:
|
||||
evt = Event()
|
||||
self.pending_responses[expected] = {'event': evt, 'data': None}
|
||||
|
||||
self._tx_queue.put(msg)
|
||||
|
||||
if not expected:
|
||||
return None # no response expected
|
||||
|
||||
# Wait for response
|
||||
if evt.wait(timeout=timeout):
|
||||
data = self.pending_responses[expected]['data']
|
||||
del self.pending_responses[expected]
|
||||
return data
|
||||
else:
|
||||
del self.pending_responses[expected]
|
||||
if attempt < retries:
|
||||
# Drain serial input buffer and message queue, then retry
|
||||
self.serial_snoop.serial_connection.reset_input_buffer()
|
||||
time.sleep(0.05)
|
||||
while not self.serial_snoop.rx_msg_queue.empty():
|
||||
try:
|
||||
self.serial_snoop.rx_msg_queue.get_nowait()
|
||||
except Empty:
|
||||
break
|
||||
print(f" [RETRY] {APTProtocol.get_name(msg_id)} attempt {attempt+2}")
|
||||
|
||||
raise TimeoutError(f"Timeout waiting for {hex(expected)}")
|
||||
|
||||
def send_message(self, msg_id, **kwargs):
|
||||
'''Build and queue a message for transmission (fire-and-forget).'''
|
||||
msg = APTProtocol.build_message(msg_id, **kwargs)
|
||||
self._tx_queue.put(msg)
|
||||
|
||||
# ── Connection management ────────────────────────────────────
|
||||
|
||||
def disconnect(self):
|
||||
if (self.serial_snoop and
|
||||
self.am_listening is True):
|
||||
# Stop polling first
|
||||
self._polling_active = False
|
||||
# Queue disconnect messages for the TX worker to send
|
||||
for addr in [0x11, 0x21, 0x22]:
|
||||
self._tx_queue.put(
|
||||
APTProtocol.build_message(0x0002, destination=addr,
|
||||
source=0x01))
|
||||
time.sleep(0.2) # let TX worker flush them out
|
||||
# Stop all worker loops, then wait for threads to exit
|
||||
self.am_listening = False
|
||||
self.serial_snoop.stop()
|
||||
self._rx_thread.join()
|
||||
self._tx_thread.join()
|
||||
self._poll_thread.join()
|
||||
self.serial_snoop.join()
|
||||
# Close port only after all threads are done
|
||||
self.serial_snoop.close()
|
||||
|
||||
# ── State update handlers ────────────────────────────────────
|
||||
|
||||
def _update0x491(self, msg):
|
||||
'''
|
||||
_update0x491 - Internal function for handling USTATUSUPDATE
|
||||
messages and updating the data for that particular axis sending
|
||||
the message.
|
||||
'''
|
||||
if msg['source'] == 0x21:
|
||||
ch = 0
|
||||
elif msg['source'] == 0x22:
|
||||
ch = 1
|
||||
else:
|
||||
return
|
||||
|
||||
self.positions[ch] = msg['position'] / self.counts_per_mm
|
||||
self.act_velocities[ch] = msg['velocity'] / self.velocity_scaling
|
||||
self.current_demand[ch] = msg['motor_current']
|
||||
|
||||
if(msg['status_bits'] & StatusBits.MOT_ANY_ERR):
|
||||
self.am_error[ch] = True
|
||||
else:
|
||||
self.am_error[ch] = False
|
||||
|
||||
if(msg['status_bits'] & StatusBits.MOT_ANY_MOVE):
|
||||
self.am_moving[ch] = True
|
||||
else:
|
||||
self.am_moving[ch] = False
|
||||
|
||||
if(msg['status_bits'] & StatusBits.MOT_SB_HOMED):
|
||||
self.am_homed[ch] = True
|
||||
|
||||
def _update0x0464(self, msg):
|
||||
'''
|
||||
_update0x0464 - internal function for MOVE_COMPLETED messages.
|
||||
Updates position, velocity, and moving state.
|
||||
'''
|
||||
if msg['source'] == 0x21:
|
||||
ch = 0
|
||||
elif msg['source'] == 0x22:
|
||||
ch = 1
|
||||
else:
|
||||
return
|
||||
|
||||
self.positions[ch] = msg['position'] / self.counts_per_mm
|
||||
self.act_velocities[ch] = msg['velocity'] / self.velocity_scaling
|
||||
self.current_demand[ch] = msg['motor_current']
|
||||
self.am_moving[ch] = False
|
||||
return
|
||||
|
||||
def _update0x0212(self, msg):
|
||||
'''
|
||||
_update0x0212 - internal function that listens for CHANENABLESTATE
|
||||
messages.
|
||||
'''
|
||||
if msg['source'] == 0x21:
|
||||
ch = 0
|
||||
elif msg['source'] == 0x22:
|
||||
ch = 1
|
||||
else:
|
||||
raise ValueError("Wherever this message came from, it's WRONG!")
|
||||
|
||||
if msg['enable_state'] == 0x01:
|
||||
self.am_enabled[ch] = True # enabled
|
||||
elif msg['enable_state'] == 0x02:
|
||||
self.am_enabled[ch] = False # disabled
|
||||
else:
|
||||
raise ValueError("Am I a joke to you? WTF did this even come from?!")
|
||||
|
||||
# ── Axis control ─────────────────────────────────────────────
|
||||
|
||||
def enable_axis(self, axis):
|
||||
'''Enable the specified axis (0x21 = X, 0x22 = Y).'''
|
||||
self.send_message(0x0210, chan_ident=1, enable_state=0x01,
|
||||
destination=axis, source=0x01)
|
||||
|
||||
def disable_axis(self, axis):
|
||||
'''Disable the specified axis (0x21 = X, 0x22 = Y).'''
|
||||
self.send_message(0x0210, chan_ident=1, enable_state=0x02,
|
||||
destination=axis, source=0x01)
|
||||
|
||||
def toggle_enabled_state(self, axis):
|
||||
'''
|
||||
toggle_enabled_state(axis) - enables the axis if disabled. disables
|
||||
if enabled. not much more to it.
|
||||
'''
|
||||
if axis == 0x21:
|
||||
ch = 0
|
||||
elif axis == 0x22:
|
||||
ch = 1
|
||||
else:
|
||||
raise ValueError("I don't know that axis!")
|
||||
# get the old state and flip it like a sample
|
||||
new_state = not self.am_enabled[ch]
|
||||
self.send_message(0x0210, chan_ident=1,
|
||||
enable_state=0x01 if new_state else 0x02,
|
||||
destination=axis, source=0x01)
|
||||
|
||||
def home_axis(self, axis, timeout=60.0):
|
||||
'''
|
||||
home_axis(axis, timeout=60): Blocking home command. Required at
|
||||
power up. Default timeout is 60s, but 20-30s is fine as well if
|
||||
you're in that much of a hurry.
|
||||
'''
|
||||
if axis == 0x21:
|
||||
ch = 0
|
||||
elif axis == 0x22:
|
||||
ch = 1
|
||||
else:
|
||||
raise ValueError("I don't know that axis!")
|
||||
|
||||
self.send_and_wait(0x0443, timeout=timeout, chan_ident=1,
|
||||
destination=axis, source=0x01)
|
||||
return
|
||||
|
||||
def move_axis_relative(self, axis, distance_in_mm, timeout=10.0):
|
||||
'''
|
||||
move_axis_relative(axis, distance_in_mm, timeout=10):
|
||||
moves the specified axis a specified distance in mm.
|
||||
Timeout defaults to ten seconds.
|
||||
'''
|
||||
# sanity check
|
||||
if axis == 0x21 and abs(distance_in_mm) > 110.0:
|
||||
raise ValueError("You can't move farther than the stage is long.")
|
||||
elif axis == 0x22 and abs(distance_in_mm) > 75.0:
|
||||
raise ValueError("You can't move farther than the stage is wide.")
|
||||
|
||||
_distance_in_encoder = int(round(distance_in_mm * self.counts_per_mm))
|
||||
self.send_and_wait(0x0448, timeout=timeout, chan_ident=1,
|
||||
relative_distance=_distance_in_encoder,
|
||||
destination=axis, source=0x01)
|
||||
return
|
||||
|
||||
def move_axis_absolute(self, axis, position_in_mm, timeout=10.0):
|
||||
'''
|
||||
move_axis_absolute(axis, position_in_mm, timeout=10):
|
||||
moves the specified axis to an absolute position in mm.
|
||||
Timeout defaults to ten seconds.
|
||||
'''
|
||||
if axis == 0x21 and (position_in_mm < 0.0 or position_in_mm > 110.0):
|
||||
raise ValueError("Position out of range for X axis (0-110 mm).")
|
||||
elif axis == 0x22 and (position_in_mm < 0.0 or position_in_mm > 75.0):
|
||||
raise ValueError("Position out of range for Y axis (0-75 mm).")
|
||||
|
||||
_position_in_encoder = int(round(position_in_mm * self.counts_per_mm))
|
||||
self.send_and_wait(0x0453, timeout=timeout, chan_ident=1,
|
||||
absolute_distance=_position_in_encoder,
|
||||
destination=axis, source=0x01)
|
||||
return
|
||||
|
||||
# ── Velocity parameters ──────────────────────────────────────
|
||||
|
||||
def get_velocity_params(self, axis, timeout=5.0):
|
||||
'''
|
||||
get_velocity_params(axis): Queries the current velocity parameters
|
||||
for the specified axis. Returns a dict with keys:
|
||||
min_velocity (mm/s), acceleration (mm/s2), max_velocity (mm/s)
|
||||
'''
|
||||
if axis == 0x21:
|
||||
ch = 0
|
||||
elif axis == 0x22:
|
||||
ch = 1
|
||||
else:
|
||||
raise ValueError("I don't know that axis!")
|
||||
|
||||
result = self.send_and_wait(0x0414, timeout=timeout, chan_ident=1,
|
||||
zero_this=0x00, destination=axis,
|
||||
source=0x01)
|
||||
params = {
|
||||
'min_velocity': result['min_velocity'] / self.velocity_scaling,
|
||||
'acceleration': result['acceleration'] / self.accel_scaling,
|
||||
'max_velocity': result['max_velocity'] / self.velocity_scaling,
|
||||
}
|
||||
|
||||
self.max_velocities[ch] = params['max_velocity']
|
||||
self.max_accels[ch] = params['acceleration']
|
||||
|
||||
return params
|
||||
|
||||
def set_velocity_params(self, axis, max_velocity=None, acceleration=None):
|
||||
'''
|
||||
set_velocity_params(axis, max_velocity=None, acceleration=None):
|
||||
Sets velocity and/or acceleration for the specified axis.
|
||||
Values are in mm/s and mm/s2 respectively. Any parameter
|
||||
left as None keeps its current value.
|
||||
'''
|
||||
if axis == 0x21:
|
||||
ch = 0
|
||||
elif axis == 0x22:
|
||||
ch = 1
|
||||
else:
|
||||
raise ValueError("I don't know that axis!")
|
||||
|
||||
# Only query current params if we need to fill in a missing value
|
||||
if max_velocity is None or acceleration is None:
|
||||
current = self.get_velocity_params(axis)
|
||||
if max_velocity is None:
|
||||
max_velocity = current['max_velocity']
|
||||
if acceleration is None:
|
||||
acceleration = current['acceleration']
|
||||
|
||||
# Update the cached values
|
||||
self.max_velocities[ch] = max_velocity
|
||||
self.max_accels[ch] = acceleration
|
||||
|
||||
_min_v = 0
|
||||
_accel = int(round(acceleration * self.accel_scaling))
|
||||
_max_v = int(round(max_velocity * self.velocity_scaling))
|
||||
|
||||
self.send_message(0x0413, chan_ident=1,
|
||||
min_velocity=_min_v,
|
||||
acceleration=_accel,
|
||||
max_velocity=_max_v,
|
||||
destination=axis, source=0x01)
|
||||
|
||||
# ── Trigger control ───────────────────────────────────────
|
||||
|
||||
def set_trigger(self, axis, mode):
|
||||
'''
|
||||
set_trigger(axis, mode): Sets the trigger mode for the specified
|
||||
axis. Mode should be a TriggerBitsServo value or combination.
|
||||
'''
|
||||
self.send_message(0x0500, chan_ident=1, mode=int(mode),
|
||||
destination=axis, source=0x01)
|
||||
|
||||
def get_trigger(self, axis, timeout=5.0):
|
||||
'''
|
||||
get_trigger(axis): Queries the current trigger mode for the
|
||||
specified axis. Returns the mode byte as a TriggerBitsServo.
|
||||
'''
|
||||
result = self.send_and_wait(0x0501, timeout=timeout,
|
||||
chan_ident=1, mode=0x00,
|
||||
destination=axis, source=0x01)
|
||||
return TriggerBitsServo(result['mode'])
|
||||
|
||||
def set_trigger_trigin_high(self, axis):
|
||||
'''Set trigger input to logic high.'''
|
||||
self.set_trigger(axis, TriggerBitsServo.TRIGIN_HIGH)
|
||||
|
||||
def set_trigger_trigin_relmove(self, axis):
|
||||
'''Set trigger input to initiate a relative move.'''
|
||||
self.set_trigger(axis, TriggerBitsServo.TRIGIN_RELMOVE)
|
||||
|
||||
def set_trigger_trigin_absmove(self, axis):
|
||||
'''Set trigger input to initiate an absolute move.'''
|
||||
self.set_trigger(axis, TriggerBitsServo.TRIGIN_ABSMOVE)
|
||||
|
||||
def set_trigger_trigin_homemove(self, axis):
|
||||
'''Set trigger input to initiate a home move.'''
|
||||
self.set_trigger(axis, TriggerBitsServo.TRIGIN_HOMEMOVE)
|
||||
|
||||
def set_trigger_trigout_high(self, axis):
|
||||
'''Set trigger output to logic high.'''
|
||||
self.set_trigger(axis, TriggerBitsServo.TRIGOUT_HIGH)
|
||||
|
||||
def set_trigger_trigout_inmotion(self, axis):
|
||||
'''Set trigger output high while axis is in motion.'''
|
||||
self.set_trigger(axis, TriggerBitsServo.TRIGOUT_INMOTION)
|
||||
|
||||
def set_trigger_trigout_motioncomplete(self, axis):
|
||||
'''Set trigger output to pulse when motion completes.'''
|
||||
self.set_trigger(axis, TriggerBitsServo.TRIGOUT_MOTIONCOMPLETE)
|
||||
|
||||
def set_trigger_trigout_maxvelocity(self, axis):
|
||||
'''Set trigger output to pulse at max velocity.'''
|
||||
self.set_trigger(axis, TriggerBitsServo.TRIGOUT_MAXVELOCITY)
|
||||
|
||||
def set_trigger_trigout_maxv(self, axis):
|
||||
'''Set trigger output high + pulse at max velocity (TRIGOUT_MAXV).'''
|
||||
self.set_trigger(axis, TriggerBitsServo.TRIGOUT_MAXV)
|
||||
@@ -0,0 +1,94 @@
|
||||
'''
|
||||
SRAS Serial Communication Tools
|
||||
Thomas Ales | Feb 2026
|
||||
Version 1
|
||||
'''
|
||||
from threading import Thread
|
||||
from queue import Queue
|
||||
import serial
|
||||
import struct
|
||||
import time
|
||||
|
||||
class SerialSnooper(Thread):
|
||||
|
||||
def __init__(self, _port, _spd):
|
||||
super().__init__()
|
||||
self.serial_connection = None
|
||||
self.serial_port = _port
|
||||
self.serial_speed = _spd
|
||||
self.am_listening = False
|
||||
self.rx_msg_queue = Queue()
|
||||
|
||||
def run(self):
|
||||
'''
|
||||
run() - Starts up the serial listener, checks if the port was
|
||||
opened successfully, and if so begins
|
||||
listening for APT messages.
|
||||
'''
|
||||
self.serial_connection = serial.Serial(port=self.serial_port,
|
||||
baudrate=self.serial_speed,
|
||||
rtscts=True, timeout=0.05)
|
||||
if self.serial_connection.is_open is True:
|
||||
# Send disconnect to stop any ongoing auto-updates from
|
||||
# a previous session
|
||||
for addr in [0x11, 0x21, 0x22]:
|
||||
disconnect_msg = struct.pack('<HBBBB', 0x0002,
|
||||
0x00, 0x00, addr, 0x01)
|
||||
self.serial_connection.write(disconnect_msg)
|
||||
|
||||
# Wait for controller to process, then flush everything
|
||||
time.sleep(0.2)
|
||||
self.serial_connection.reset_output_buffer()
|
||||
self.serial_connection.reset_input_buffer()
|
||||
|
||||
# Discard any remaining data that arrived
|
||||
time.sleep(0.1)
|
||||
if self.serial_connection.in_waiting > 0:
|
||||
self.serial_connection.read(self.serial_connection.in_waiting)
|
||||
|
||||
self.am_listening = True
|
||||
_rxbuf = bytearray()
|
||||
while self.am_listening is True:
|
||||
try:
|
||||
# Read whatever is available (or wait up to timeout)
|
||||
_chunk = self.serial_connection.read(
|
||||
max(1, self.serial_connection.in_waiting))
|
||||
if _chunk:
|
||||
_rxbuf.extend(_chunk)
|
||||
|
||||
# Process complete messages from the buffer
|
||||
while len(_rxbuf) >= 6:
|
||||
# Check if this is a long message (bit 7 of byte 4)
|
||||
if _rxbuf[4] & 0x80:
|
||||
_msglen = struct.unpack("<H", _rxbuf[2:4])[0]
|
||||
total = 6 + _msglen
|
||||
if len(_rxbuf) < total:
|
||||
break # need more bytes
|
||||
_packet = bytes(_rxbuf[:total])
|
||||
del _rxbuf[:total]
|
||||
else:
|
||||
_packet = bytes(_rxbuf[:6])
|
||||
del _rxbuf[:6]
|
||||
|
||||
self.rx_msg_queue.put_nowait(_packet)
|
||||
|
||||
except (serial.SerialException, TypeError, OSError):
|
||||
break
|
||||
return
|
||||
|
||||
def stop(self):
|
||||
'''
|
||||
stop() - Signals the listener loop to stop. Call join() after
|
||||
this to wait for the thread to exit, then call close() to
|
||||
release the serial port.
|
||||
'''
|
||||
self.am_listening = False
|
||||
|
||||
def close(self):
|
||||
'''
|
||||
close() - Closes the serial port. Only call after the
|
||||
thread has been joined.
|
||||
'''
|
||||
if self.serial_connection and self.serial_connection.is_open:
|
||||
self.serial_connection.close()
|
||||
|
||||
+107
-61
@@ -21,7 +21,7 @@ from hardware.helios_laser import HeliosLaser, PulseMode
|
||||
from hardware.uc480_camera import UC480Camera, CameraStreamThread
|
||||
|
||||
# Import stage controller and motion worker
|
||||
from hardware.bbd202 import MotionController
|
||||
from hardware.pybbd202 import ThorlabsServoDriver, AXIS_X, AXIS_Y, TriggerBitsServo
|
||||
from scanengine.motion_worker import MotionWorker
|
||||
|
||||
# Import scan planning tool
|
||||
@@ -54,33 +54,7 @@ class ScanWorker(QtCore.QObject):
|
||||
|
||||
@QtCore.pyqtSlot()
|
||||
def run_scan(self):
|
||||
"""
|
||||
Execute the full scanning process.
|
||||
|
||||
TODO: Implement your own motion control logic here.
|
||||
|
||||
Available data:
|
||||
self.scan_params - dict containing:
|
||||
'scan_boxes' - list of scan box dicts with:
|
||||
'angle_degrees' - rotation angle
|
||||
'start' - (x_start, y_start) in mm
|
||||
'end' - (x_end, y_end) in mm
|
||||
'row_spacing' - spacing between rows in mm
|
||||
|
||||
self.motion_worker.controller - MotionController instance (if connected)
|
||||
|
||||
self.should_stop - set to True when user requests abort
|
||||
|
||||
Signals to emit:
|
||||
self.scan_started.emit() - at start
|
||||
self.angle_started.emit(angle_idx, total_angles) - when starting each angle
|
||||
self.line_started.emit(line_idx, total_lines, y_pos) - when starting each line
|
||||
self.current_progress.emit(percent) - progress for current angle
|
||||
self.overall_progress.emit(percent) - overall progress
|
||||
self.status_message.emit(message) - status updates
|
||||
self.scan_completed.emit() - on successful completion
|
||||
self.scan_failed.emit(error_msg) - on failure
|
||||
"""
|
||||
"""Execute the full scanning process."""
|
||||
# Pause motion worker polling during scan to avoid conflicts
|
||||
if self.motion_worker:
|
||||
self.motion_worker.scanning_active = True
|
||||
@@ -88,40 +62,114 @@ class ScanWorker(QtCore.QObject):
|
||||
try:
|
||||
self.scan_started.emit()
|
||||
|
||||
# Extract parameters
|
||||
scan_boxes = self.scan_params.get('scan_boxes', [])
|
||||
num_angles = len(scan_boxes)
|
||||
row_spacing = self.scan_params.get('row_spacing', 0.1)
|
||||
scan_velocity = self.scan_params.get('scan_velocity_mm_s', 200.0)
|
||||
scan_accel = self.scan_params.get('scan_acceleration_mm_s2', 500.0)
|
||||
|
||||
print(f"Scan worker: Starting scan with {num_angles} angles")
|
||||
print(f"Row spacing: {row_spacing} mm")
|
||||
print(f"Row spacing: {row_spacing} mm, velocity: {scan_velocity} mm/s")
|
||||
|
||||
controller = self.motion_worker.controller if self.motion_worker else None
|
||||
if not controller:
|
||||
self.scan_failed.emit("No motion controller connected")
|
||||
return
|
||||
|
||||
# TODO: Implement your motion control logic here
|
||||
#
|
||||
# For each angle in scan_boxes:
|
||||
# - Move to start position (x_start, y_start)
|
||||
# - For each row from y_start to y_end with row_spacing:
|
||||
# - Move X from x_start to x_end (flying scan)
|
||||
# - Move to next row (X back to x_start, Y to next row)
|
||||
#
|
||||
# The MotionController provides these methods:
|
||||
# controller.move_to_fast(x=mm, y=mm) - send move commands
|
||||
# controller.get_position(dest, timeout) - get current position
|
||||
# controller.poll_until_idle(tolerance, timeout) - poll until settled
|
||||
# controller.set_velocity_params(dest, min_vel, accel, max_vel)
|
||||
# controller.start_update_messages() - enable status updates
|
||||
# etc.
|
||||
# Store original velocity params for restoration
|
||||
orig_x_velocity = controller.max_velocities[0]
|
||||
orig_x_accel = controller.max_accels[0]
|
||||
orig_y_velocity = controller.max_velocities[1]
|
||||
orig_y_accel = controller.max_accels[1]
|
||||
|
||||
self.scan_failed.emit("Motion control not implemented - please implement run_scan()")
|
||||
# Configure stage for high-speed scanning
|
||||
controller.set_velocity_params(AXIS_X, max_velocity=scan_velocity, acceleration=scan_accel)
|
||||
controller.set_velocity_params(AXIS_Y, max_velocity=scan_velocity, acceleration=scan_accel)
|
||||
|
||||
# Set X-axis trigger output HIGH during motion (for oscilloscope sync)
|
||||
controller.set_trigger(AXIS_X, TriggerBitsServo.TRIGOUT_INMOTION)
|
||||
|
||||
self.status_message.emit("Scan configured, starting raster...")
|
||||
|
||||
# Main scan loop
|
||||
for angle_idx, scan_box in enumerate(scan_boxes):
|
||||
if self.should_stop:
|
||||
self.scan_failed.emit("Scan aborted by user")
|
||||
return
|
||||
|
||||
self.angle_started.emit(angle_idx, num_angles)
|
||||
angle_deg = scan_box.get('angle_degrees', 0)
|
||||
self.status_message.emit(f"Angle {angle_idx + 1}/{num_angles} ({angle_deg:.1f} deg)")
|
||||
|
||||
# Extract scan area boundaries
|
||||
x_start, y_start = scan_box['start']
|
||||
x_end, y_end = scan_box['end']
|
||||
|
||||
# Calculate scan lines
|
||||
y_range = y_end - y_start
|
||||
num_lines = max(1, int(y_range / row_spacing) + 1)
|
||||
|
||||
# Move to start position only for first angle
|
||||
if angle_idx == 0:
|
||||
self.status_message.emit("Moving to scan start position...")
|
||||
controller.move_axis_absolute(AXIS_X, x_start, timeout=30.0)
|
||||
controller.move_axis_absolute(AXIS_Y, y_start, timeout=30.0)
|
||||
|
||||
# Scan each line (snake/boustrophedon pattern)
|
||||
for line_idx in range(num_lines):
|
||||
if self.should_stop:
|
||||
self.scan_failed.emit("Scan aborted by user")
|
||||
return
|
||||
|
||||
y_current = y_start + line_idx * row_spacing
|
||||
if y_current > y_end:
|
||||
y_current = y_end
|
||||
|
||||
# Alternate scan direction for snake pattern
|
||||
if line_idx % 2 == 0:
|
||||
scan_start_x, scan_end_x = x_start, x_end
|
||||
else:
|
||||
scan_start_x, scan_end_x = x_end, x_start
|
||||
|
||||
self.line_started.emit(line_idx, num_lines, y_current)
|
||||
|
||||
# Position to line start (diagonal move - X and Y simultaneously)
|
||||
# Y move issued first (non-blocking from stage perspective),
|
||||
# then X move; both complete before scan line begins
|
||||
controller.move_axis_absolute(AXIS_Y, y_current, timeout=20.0)
|
||||
controller.move_axis_absolute(AXIS_X, scan_start_x, timeout=20.0)
|
||||
|
||||
# Perform scan line (trigger is HIGH during this move)
|
||||
scan_distance = abs(scan_end_x - scan_start_x)
|
||||
scan_timeout = max(10.0, scan_distance / scan_velocity * 3)
|
||||
controller.move_axis_absolute(AXIS_X, scan_end_x, timeout=scan_timeout)
|
||||
|
||||
# Update progress
|
||||
line_progress = int(100 * (line_idx + 1) / num_lines)
|
||||
self.current_progress.emit(line_progress)
|
||||
|
||||
overall = int(100 * (angle_idx + (line_idx + 1) / num_lines) / num_angles)
|
||||
self.overall_progress.emit(overall)
|
||||
|
||||
# Cleanup: disable triggers and restore original velocity
|
||||
controller.set_trigger(AXIS_X, 0)
|
||||
controller.set_velocity_params(AXIS_X, max_velocity=orig_x_velocity, acceleration=orig_x_accel)
|
||||
controller.set_velocity_params(AXIS_Y, max_velocity=orig_y_velocity, acceleration=orig_y_accel)
|
||||
|
||||
self.status_message.emit("Scan complete")
|
||||
self.scan_completed.emit()
|
||||
|
||||
except Exception as e:
|
||||
print(f"ERROR in scan worker: {e}")
|
||||
import traceback
|
||||
traceback.print_exc()
|
||||
# Best-effort cleanup on error
|
||||
try:
|
||||
if self.motion_worker and self.motion_worker.controller:
|
||||
self.motion_worker.controller.set_trigger(AXIS_X, 0)
|
||||
except Exception:
|
||||
pass
|
||||
self.scan_failed.emit(str(e))
|
||||
finally:
|
||||
# Re-enable motion worker polling
|
||||
@@ -2395,8 +2443,8 @@ class ScanVisualizationDialog(QtWidgets.QDialog):
|
||||
self.current_scan_label.setText("Checking home status...")
|
||||
|
||||
# Get home status for both axes
|
||||
x_homed = controller.is_homed_x
|
||||
y_homed = controller.is_homed_y
|
||||
x_homed = controller.am_homed[0]
|
||||
y_homed = controller.am_homed[1]
|
||||
|
||||
print(f"Home status - X: {x_homed}, Y: {y_homed}")
|
||||
|
||||
@@ -2430,15 +2478,14 @@ class ScanVisualizationDialog(QtWidgets.QDialog):
|
||||
QtWidgets.QApplication.processEvents()
|
||||
|
||||
try:
|
||||
success = controller.home_axis(controller.DEST_X_AXIS, timeout=60.0)
|
||||
if success:
|
||||
controller.home_axis(AXIS_X, timeout=60.0)
|
||||
print("X-axis homed successfully")
|
||||
self.current_scan_progress.setValue(50)
|
||||
|
||||
# Small delay to let system stabilize
|
||||
import time
|
||||
time.sleep(0.5)
|
||||
else:
|
||||
except TimeoutError:
|
||||
print("ERROR: X-axis homing timeout")
|
||||
QtWidgets.QMessageBox.critical(
|
||||
self,
|
||||
@@ -2467,15 +2514,14 @@ class ScanVisualizationDialog(QtWidgets.QDialog):
|
||||
QtWidgets.QApplication.processEvents()
|
||||
|
||||
try:
|
||||
success = controller.home_axis(controller.DEST_Y_AXIS, timeout=60.0)
|
||||
if success:
|
||||
controller.home_axis(AXIS_Y, timeout=60.0)
|
||||
print("Y-axis homed successfully")
|
||||
self.current_scan_progress.setValue(90)
|
||||
|
||||
# Small delay to let system stabilize
|
||||
import time
|
||||
time.sleep(0.5)
|
||||
else:
|
||||
except TimeoutError:
|
||||
print("ERROR: Y-axis homing timeout")
|
||||
QtWidgets.QMessageBox.critical(
|
||||
self,
|
||||
@@ -2689,16 +2735,16 @@ class OptionsDialog(QtWidgets.QDialog):
|
||||
|
||||
def populate_trigger_modes(self):
|
||||
"""Populate the trigger mode combo boxes with available options"""
|
||||
from hardware.bbd202 import TriggerMode
|
||||
from hardware.pybbd202 import TriggerBitsServo
|
||||
|
||||
trigger_options = [
|
||||
("Disabled", TriggerMode.DISABLED),
|
||||
("In/Out Relative Move", TriggerMode.IN_OUT_RELATIVE_MOVE),
|
||||
("In/Out Absolute Move", TriggerMode.IN_OUT_ABSOLUTE_MOVE),
|
||||
("In/Out Home", TriggerMode.IN_OUT_HOME),
|
||||
("In/Out Stop", TriggerMode.IN_OUT_STOP),
|
||||
("Out Only (HIGH during motion)", TriggerMode.OUT_ONLY),
|
||||
("Out Position", TriggerMode.OUT_POSITION),
|
||||
("Disabled", 0),
|
||||
("Trigger In: Relative Move", TriggerBitsServo.TRIGIN_RELMOVE),
|
||||
("Trigger In: Absolute Move", TriggerBitsServo.TRIGIN_ABSMOVE),
|
||||
("Trigger In: Home", TriggerBitsServo.TRIGIN_HOMEMOVE),
|
||||
("Trigger Out: In Motion", TriggerBitsServo.TRIGOUT_INMOTION),
|
||||
("Trigger Out: Motion Complete", TriggerBitsServo.TRIGOUT_MOTIONCOMPLETE),
|
||||
("Trigger Out: Max Velocity", TriggerBitsServo.TRIGOUT_MAXVELOCITY),
|
||||
]
|
||||
|
||||
for label, mode in trigger_options:
|
||||
|
||||
+49
-80
@@ -6,7 +6,7 @@ Provides async command queueing and position updates via Qt signals.
|
||||
"""
|
||||
|
||||
from PyQt6 import QtCore
|
||||
from hardware.bbd202 import MotionController
|
||||
from hardware.pybbd202 import ThorlabsServoDriver, AXIS_X, AXIS_Y
|
||||
import queue
|
||||
import time
|
||||
from typing import Optional, Dict, Any
|
||||
@@ -45,7 +45,7 @@ class MotionWorker(QtCore.QObject):
|
||||
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
self.controller: Optional[MotionController] = None
|
||||
self.controller: Optional[ThorlabsServoDriver] = None
|
||||
self.is_connected = False
|
||||
self.command_queue = queue.Queue()
|
||||
self.running = True
|
||||
@@ -65,9 +65,9 @@ class MotionWorker(QtCore.QObject):
|
||||
self.last_x_moving = None
|
||||
self.last_y_moving = None
|
||||
|
||||
# Position update throttling (active requests can be slow)
|
||||
# Position update throttling
|
||||
self.last_position_update_time = 0
|
||||
self.position_update_interval = 0.2 # seconds between position requests
|
||||
self.position_update_interval = 0.2 # seconds between position reads
|
||||
|
||||
# Flag to pause polling during scanning (scan worker handles its own position queries)
|
||||
self.scanning_active = False
|
||||
@@ -133,27 +133,25 @@ class MotionWorker(QtCore.QObject):
|
||||
def do_connect(self):
|
||||
"""Connect to the motion controller"""
|
||||
try:
|
||||
self.controller = MotionController()
|
||||
self.controller.connect() # ACKs are sent reactively when enable_updates=True
|
||||
self.controller = ThorlabsServoDriver()
|
||||
self.controller.connect()
|
||||
|
||||
# Enable channels
|
||||
self.controller.set_channel_enable_state(self.controller.DEST_X_AXIS, True)
|
||||
self.controller.set_channel_enable_state(self.controller.DEST_Y_AXIS, True)
|
||||
self.controller.enable_axis(AXIS_X)
|
||||
self.controller.enable_axis(AXIS_Y)
|
||||
|
||||
# Request status updates for both axes to populate status bits (including homed state)
|
||||
# This is necessary because status bits are not sent automatically after connect
|
||||
self.controller.request_status_update(self.controller.DEST_X_AXIS)
|
||||
self.controller.request_status_update(self.controller.DEST_Y_AXIS)
|
||||
# Wait a moment for the asynchronous status update responses
|
||||
time.sleep(0.2)
|
||||
# Start polling to populate cached state (positions, homed, moving, errors)
|
||||
self.controller.start_polling(interval=0.2)
|
||||
|
||||
# Wait for first polling cycle to populate status
|
||||
time.sleep(0.3)
|
||||
|
||||
# Set initial velocity parameters
|
||||
for dest in [self.controller.DEST_X_AXIS, self.controller.DEST_Y_AXIS]:
|
||||
for dest in [AXIS_X, AXIS_Y]:
|
||||
self.controller.set_velocity_params(
|
||||
dest,
|
||||
min_velocity=0.0,
|
||||
acceleration=self.acceleration,
|
||||
max_velocity=self.jog_speed
|
||||
max_velocity=self.jog_speed,
|
||||
acceleration=self.acceleration
|
||||
)
|
||||
|
||||
self.is_connected = True
|
||||
@@ -188,27 +186,23 @@ class MotionWorker(QtCore.QObject):
|
||||
return
|
||||
|
||||
try:
|
||||
# Determine destination
|
||||
dest = self.controller.DEST_X_AXIS if axis == 'x' else self.controller.DEST_Y_AXIS
|
||||
dest = AXIS_X if axis == 'x' else AXIS_Y
|
||||
|
||||
# Calculate relative distance
|
||||
distance = self.step_size * direction
|
||||
|
||||
# Set relative move parameters
|
||||
self.controller.set_move_rel_params(dest, distance)
|
||||
|
||||
# Execute the move (non-blocking - we don't wait for completion)
|
||||
# Use a very short timeout since we're doing continuous jogging
|
||||
self.controller.move_relative(dest, timeout=0.5)
|
||||
# Execute the move (blocking, with short timeout for continuous jogging)
|
||||
self.controller.move_axis_relative(dest, distance, timeout=0.5)
|
||||
|
||||
# Update position
|
||||
self.update_position()
|
||||
|
||||
self.move_completed.emit(axis)
|
||||
|
||||
except TimeoutError:
|
||||
# Timeout is expected during continuous jog - don't report as error
|
||||
pass
|
||||
except Exception as e:
|
||||
# Don't emit errors for timeout - that's expected during continuous jog
|
||||
if "timeout" not in str(e).lower():
|
||||
print(f"Jog error: {e}")
|
||||
self.error_occurred.emit(f"Jog failed: {str(e)}")
|
||||
|
||||
@@ -218,7 +212,7 @@ class MotionWorker(QtCore.QObject):
|
||||
return
|
||||
|
||||
try:
|
||||
dest = self.controller.DEST_X_AXIS if axis == 'x' else self.controller.DEST_Y_AXIS
|
||||
dest = AXIS_X if axis == 'x' else AXIS_Y
|
||||
|
||||
print(f"Homing {axis.upper()} axis...")
|
||||
self.controller.home_axis(dest, timeout=20.0)
|
||||
@@ -229,6 +223,9 @@ class MotionWorker(QtCore.QObject):
|
||||
|
||||
print(f"{axis.upper()} axis homed successfully")
|
||||
|
||||
except TimeoutError:
|
||||
print(f"Home timeout: {axis.upper()} axis")
|
||||
self.error_occurred.emit(f"Homing {axis.upper()} timed out")
|
||||
except Exception as e:
|
||||
print(f"Home error: {e}")
|
||||
self.error_occurred.emit(f"Homing {axis.upper()} failed: {str(e)}")
|
||||
@@ -244,12 +241,11 @@ class MotionWorker(QtCore.QObject):
|
||||
self.jog_speed = speed
|
||||
self.acceleration = accel
|
||||
|
||||
for dest in [self.controller.DEST_X_AXIS, self.controller.DEST_Y_AXIS]:
|
||||
for dest in [AXIS_X, AXIS_Y]:
|
||||
self.controller.set_velocity_params(
|
||||
dest,
|
||||
min_velocity=0.0,
|
||||
acceleration=self.acceleration,
|
||||
max_velocity=self.jog_speed
|
||||
max_velocity=self.jog_speed,
|
||||
acceleration=self.acceleration
|
||||
)
|
||||
|
||||
except Exception as e:
|
||||
@@ -261,8 +257,11 @@ class MotionWorker(QtCore.QObject):
|
||||
return
|
||||
|
||||
try:
|
||||
dest = self.controller.DEST_X_AXIS if axis == 'x' else self.controller.DEST_Y_AXIS
|
||||
self.controller.set_channel_enable_state(dest, enabled)
|
||||
dest = AXIS_X if axis == 'x' else AXIS_Y
|
||||
if enabled:
|
||||
self.controller.enable_axis(dest)
|
||||
else:
|
||||
self.controller.disable_axis(dest)
|
||||
state_str = "enabled" if enabled else "disabled"
|
||||
print(f"{axis.upper()} axis {state_str}")
|
||||
|
||||
@@ -275,20 +274,17 @@ class MotionWorker(QtCore.QObject):
|
||||
if not self.is_connected or not self.controller:
|
||||
return
|
||||
|
||||
# Throttle position requests to avoid slowing down the main loop
|
||||
# Throttle position reads to avoid excessive signal emission
|
||||
current_time = time.time()
|
||||
if current_time - self.last_position_update_time < self.position_update_interval:
|
||||
return
|
||||
self.last_position_update_time = current_time
|
||||
|
||||
try:
|
||||
# Actively request positions from the controller instead of relying on cached values
|
||||
# This ensures we always have up-to-date position data
|
||||
# Use longer timeout (1.5s) to accommodate high-speed scanning at 200mm/s
|
||||
x_pos = self.controller.get_position(self.controller.DEST_X_AXIS, timeout=1.5)
|
||||
y_pos = self.controller.get_position(self.controller.DEST_Y_AXIS, timeout=1.5)
|
||||
# Read cached positions (populated by polling worker)
|
||||
x_pos = self.controller.positions[0]
|
||||
y_pos = self.controller.positions[1]
|
||||
|
||||
if x_pos is not None and y_pos is not None:
|
||||
# Always emit on first update, or if position changed significantly (> 0.001mm)
|
||||
if (self.last_x is None or self.last_y is None or
|
||||
abs(x_pos - self.last_x) > 0.001 or abs(y_pos - self.last_y) > 0.001):
|
||||
@@ -296,14 +292,7 @@ class MotionWorker(QtCore.QObject):
|
||||
self.last_y = y_pos
|
||||
print(f"Position update: X={x_pos:.3f}mm, Y={y_pos:.3f}mm")
|
||||
self.position_updated.emit(x_pos, y_pos)
|
||||
# else: silently skip incomplete position data during busy scanning
|
||||
|
||||
except RuntimeError as e:
|
||||
# RuntimeError indicates actual hardware error (overtemp, encoder fault, etc.)
|
||||
print(f"CRITICAL: Motor error detected: {e}")
|
||||
self.error_occurred.emit(str(e))
|
||||
# Stop requesting position updates to avoid spam
|
||||
self.is_connected = False
|
||||
except Exception as e:
|
||||
print(f"Error updating position: {e}")
|
||||
import traceback
|
||||
@@ -315,8 +304,8 @@ class MotionWorker(QtCore.QObject):
|
||||
return
|
||||
|
||||
try:
|
||||
x_homed = self.controller.is_homed_x
|
||||
y_homed = self.controller.is_homed_y
|
||||
x_homed = self.controller.am_homed[0]
|
||||
y_homed = self.controller.am_homed[1]
|
||||
|
||||
# Only emit if status changed
|
||||
if x_homed != self.last_x_homed or y_homed != self.last_y_homed:
|
||||
@@ -332,42 +321,22 @@ class MotionWorker(QtCore.QObject):
|
||||
def update_motion_status(self):
|
||||
"""Update motion status and emit signal if changed.
|
||||
|
||||
NOTE: On BBD202 firmware v2.1.5, the is_in_motion_x/y properties
|
||||
do NOT reliably detect motion - they may always return False even
|
||||
during active movement. This is a known firmware limitation.
|
||||
|
||||
For scan execution, use the ScanWorker.move_and_wait() method which
|
||||
uses position-based motion detection instead of status bits.
|
||||
|
||||
This UI status display is best-effort only.
|
||||
The new driver's polling worker keeps am_moving[], am_error[]
|
||||
up to date automatically via status update messages.
|
||||
"""
|
||||
if not self.is_connected or not self.controller:
|
||||
return
|
||||
|
||||
try:
|
||||
# Actively poll for status updates
|
||||
self.controller.poll_status()
|
||||
|
||||
# Check for any error conditions
|
||||
error_msg = self.controller.check_for_errors()
|
||||
if error_msg:
|
||||
print(f"Motor error detected: {error_msg}")
|
||||
self.error_occurred.emit(error_msg)
|
||||
self.controller.clear_last_error()
|
||||
if self.controller.am_error[0]:
|
||||
self.error_occurred.emit("X-axis error detected")
|
||||
if self.controller.am_error[1]:
|
||||
self.error_occurred.emit("Y-axis error detected")
|
||||
|
||||
# Read the cached status (may not accurately reflect motion on some firmware)
|
||||
x_moving = self.controller.is_in_motion_x
|
||||
y_moving = self.controller.is_in_motion_y
|
||||
|
||||
# Also check if there are pending moves (more reliable)
|
||||
if self.controller.is_move_pending():
|
||||
# If there are pending moves, we're likely still moving
|
||||
# This provides a backup indication when status bits fail
|
||||
pending = self.controller.get_pending_targets()
|
||||
if self.controller.DEST_X_AXIS in pending:
|
||||
x_moving = True
|
||||
if self.controller.DEST_Y_AXIS in pending:
|
||||
y_moving = True
|
||||
# Read cached motion status (updated by polling worker)
|
||||
x_moving = self.controller.am_moving[0]
|
||||
y_moving = self.controller.am_moving[1]
|
||||
|
||||
# Only emit if status changed
|
||||
if x_moving != self.last_x_moving or y_moving != self.last_y_moving:
|
||||
|
||||
Reference in New Issue
Block a user