{
this.props.instrumentsStore.connectionParameters =
connectionParameters;
}}
availableConnections={
instrument.availableConnections
}
serialBaudRates={instrument.serialBaudRates}
/>
);
} else {
if (connection.isTransitionState) {
info = ;
}
const { ConnectionParametersDetails } =
require("home/instruments/instrument-object-details") as typeof import("home/instruments/instrument-object-details");
connectionParameters = (
);
abort = (
);
}
}
return (
{info}
{error}
{connectionParameters}
{abort}
);
}
}
);
export const SelectInstrumentDialog = observer(
class SelectInstrumentDialog extends React.Component<{
projectStore?: ProjectStore;
instrumentsStore: InstrumentsStore;
selectAndConnect?: boolean;
resolve: (instrument: InstrumentObject | undefined) => void;
}> {
connectToInstrument: boolean = false;
connectionParameters: ConnectionParameters | null;
dispose: any;
constructor(props: any) {
super(props);
makeObservable(this, {
connectToInstrument: observable
});
}
componentDidMount() {
this.dispose = autorun(() => {
if (
this.connectToInstrument &&
this.props.instrumentsStore.selectedInstrument &&
this.props.instrumentsStore.selectedInstrument.isConnected
) {
this.props.resolve(
this.props.instrumentsStore.selectedInstrument
);
}
});
this.props.instrumentsStore.onSelectInstrument = this.onOk;
}
componentWillUnmount() {
this.dispose();
this.props.instrumentsStore.onSelectInstrument = undefined;
}
onOk = () => {
const instrument = this.props.instrumentsStore.selectedInstrument;
if (instrument) {
if (this.connectToInstrument) {
this.props.instrumentsStore.selectedInstrumentConnect();
} else {
if (
this.props.selectAndConnect &&
!instrument.isConnected
) {
runInAction(() => (this.connectToInstrument = true));
} else {
this.props.resolve(instrument);
}
}
}
};
render() {
const instrument = this.props.instrumentsStore.selectedInstrument;
let content;
if (this.connectToInstrument && instrument) {
content = (
{instrument.connection?.isIdle
? `Connect to ${instrument.name}`
: `Connecting to ${instrument.name} ...`}
);
} else {
content = (
);
}
const dialog = (
);
if (this.props.projectStore) {
return (
{dialog}
);
} else {
return dialog;
}
}
}
);
export async function showSelectInstrumentDialog(
projectStore: ProjectStore | undefined,
name?: string,
instrumentId?: string | undefined,
selectAndConnect?: boolean
) {
return new Promise(resolve => {
const instrumentsStore = new InstrumentsStore(true);
instrumentsStore.selectedInstrumentId = instrumentId;
const [modalDialog] = showDialog(
{
if (instrument) {
resolve(instrument);
}
modalDialog.close();
}}
/>,
{
jsPanel: {
id: "select-instrument-5",
title: name ? `Select: ${name}` : "Select Instrument",
width: 920,
height: 680
}
}
);
});
}
////////////////////////////////////////////////////////////////////////////////
async function connectToInstrument(instrument: InstrumentObject) {
if (!instrument.lastConnection) {
return;
}
const connection = instrument.connection;
connection.connect();
for (let i = 0; i < 10; i++) {
try {
await connection.acquire(false);
connection.release();
return;
} catch (err) {
await new Promise(resolve => setTimeout(resolve, 100));
}
}
}
type InstrumentConstructorParams = "string" | { id: "string" };
function getInstrumentIdFromConstructorParams(
constructorParams: InstrumentConstructorParams | undefined
) {
return constructorParams == null
? null
: typeof constructorParams === "string"
? constructorParams
: (constructorParams.id as string);
}
registerObjectVariableType("Instrument", {
editConstructorParams: async (
variable: IVariable,
constructorParams?: InstrumentConstructorParams,
runtime?: boolean
): Promise => {
let instrument = await showSelectInstrumentDialog(
ProjectEditor.getProjectStore(variable as any),
variable.description || variable.fullName,
getInstrumentIdFromConstructorParams(constructorParams) ??
undefined,
!(runtime === false)
);
return instrument
? {
id: instrument.id
}
: undefined;
},
createValue: (
constructorParams: InstrumentConstructorParams,
isRuntime: boolean
) => {
const instrumentId =
getInstrumentIdFromConstructorParams(constructorParams);
if (instrumentId) {
const { instruments } =
require("instrument/instrument-object") as typeof InstrumentObjectModule;
const instrument = instruments.get(instrumentId);
if (instrument) {
if (isRuntime) {
connectToInstrument(instrument);
}
return instrument;
}
}
return {
constructorParams,
status: {
label: "Unknown instrument",
error: `Instrument with ID [${constructorParams}] is not found`
}
};
},
destroyValue: (value: IObjectVariableValue) => {},
getValue: (variableValue: any): IObjectVariableValue | null => {
const { instruments } =
require("instrument/instrument-object") as typeof InstrumentObjectModule;
return instruments.get(variableValue.id) ?? null;
},
valueFieldDescriptions: [
{
name: "id",
valueType: "string",
getFieldValue: (value: InstrumentObject): string => {
return value.id;
}
},
{
name: "isConnected",
valueType: "boolean",
getFieldValue: (value: InstrumentObject): boolean => {
return value.isConnected;
}
}
]
});