Sets instrument coordinate system. Accepts an int or string.
424742
def coordinate_system(self, coordsys):
        """"""
        if coordsys.upper() == "ENU":
            ncs = 0
        elif coordsys.upper() == "XYZ":
            ncs = 1
        elif coordsys.upper() == "BEAM":
            ncs = 2
        elif coordsys in [0, 1, 2]:
            ncs = coordsys
        else:
            raise ValueError("Invalid coordinate system selection")
        self.pdx.CoordinateSystem = ncs
1086053
def update(self, settings):
        '''
        

        '''
        Instrument.update(self, settings)

        for key, value in settings.items():
            if key == 'test1':
                self._internal_state = value
839838
def setValue(self, value):
        """"""
        if self.name in self._CUSTOM_INT_PARAMS:
            value = int(value)
        elif self.name in self._CUSTOM_FLOAT_PARAMS:
            value = float(value)
        elif self.name in self._CUSTOM_BOOL_PARAMS:
            value = bool(value)
        elif self.name in self._CUSTOM_INTLIST_PARAMS:
            value = readIntlist(value)
        elif self.name in self._CUSTOM_DICT_PARAMS:
            parser = Parser()
            value = parser.parse(value)
        elif self.name == "note":
            value = unicode(value)
        self._value = value
316252
def set(self, **kwargs):
        
        self.explorer.set(**kwargs)
        self.protocoler.set(**kwargs)
        self.tone_calibrator.set(**kwargs)
        self.charter.set(**kwargs)
        self.bs_calibrator.set(**kwargs)
        self.mphone_calibrator.set(**kwargs)
781250
public void set(boolean index, double x, double y) {
        this.MODE = LINES;
        if (index == true) {
            this.x1 = x;
            this.y1 = y;
        } else {
            this.x2 = x;
            this.y2 = y;
        }

        calcG();
        dx[0] = x1 - this.x;
        dx[1] = x2 - this.x;
        dy[0] = y1 - this.y;
        dy[1] = y2 - this.y;
        dz[0] = z1 - 0;
        dz[1] = z2 - 0;
        if (dashed) calcDashedLine();
    }
599293
def set_coordsys(self, coordsys):
        
        if coordsys in self.coordsys_mapping:
            self.coordsys = self.coordsys_mapping[coordsys]
        else:
            self.coordsys = coordsys
919112
def update_instrument_config(
        instrument, measured_center) -> Tuple[Point, float]:
    
    from copy import deepcopy
    from opentrons.trackers.pose_tracker import update

    robot = instrument.robot
    config = robot.config
    instrument_offset = deepcopy(config.instrument_offset)

    dx, dy, dz = array(measured_center) - config.tip_probe.center

    log.debug("This is measured probe center dx {}".format(Point(dx, dy, dz)))
    # any Z offset will adjust the tip length, so instruments have Z=0 offset
    old_x, old_y, _ = instrument_offset[instrument.mount][instrument.type]
    instrument_offset[instrument.mount][instrument.type] = \
        (old_x - dx, old_y - dy, 0.0)
    tip_length = deepcopy(config.tip_length)
    tip_length[instrument.name] = tip_length[instrument.name] + dz

    config = config \
        ._replace(instrument_offset=instrument_offset) \
        ._replace(tip_length=tip_length)
    robot.config = config
    log.debug("Updating config for {} instrument".format(instrument.mount))
    robot_configs.save_robot_settings(config)

    new_coordinates = change_base(
        robot.poses,
        src=instrument,
        dst=instrument.instrument_mover) - Point(dx, dy, 0.0)
    robot.poses = update(robot.poses, instrument, new_coordinates)

    return robot.config
325609
public void setPos(int pos) {

        position = pos;

        NodeAVL n = nPrimaryNode;

        while (n != null) {
            ((NodeAVLDisk) n).iData = position;
            n                       = n.nNext;
        }
    }
86323
public void setLocation(int x, int y)
    {
        screenX = UtilMath.clamp(x, minX, maxX);
        screenY = UtilMath.clamp(y, minY, maxY);
    }
797880
def setPosition(self, poiID, x, y):
        
        self._connection._beginMessage(
            tc.CMD_SET_POI_VARIABLE, tc.VAR_POSITION, poiID, 1 + 8 + 8)
        self._connection._string += struct.pack("!Bdd", tc.POSITION_2D, x, y)
        self._connection._sendExact()
493414
public boolean setPosition(float position) {
		if (playing) {
			requiredPosition = -1;
			
			positioning = true;
			playing = false;
			boolean result = sound.setPosition(position);
			playing = true;
			positioning = false;

			return result;
		} else {
			requiredPosition = position;
			return false;
		}
	}
320618
def _set_position(self, value):
        
        pX, pY = self.position
        x, y = value
        dX = x - pX
        dY = y - pY
        self.moveBy((dX, dY))
149106
protected void determineCoordinates(){
		for (int i=0; i<numPoints; i++){
			coordinates.set(i, getPointCoordinate(i));
		}
	}
1261685
private void instrument(String id, int port, MetricRegistry registry) {
        this.setPort(port);
        this.accepts = registry.meter(id + "-accepts");
        this.connects = registry.meter(id + "-connects");
        this.disconnects = registry.meter(id + "-disconnects");
        this.connections = registry.counter(id + "-active-connections");

    }
127622
private void set(int position, boolean val) {
        // enlarge bitString if necessary
        if (position >= bitString.length) {
            boolean[] tmp = new boolean[position+1];
            System.arraycopy(bitString, 0, tmp, 0, bitString.length);
            bitString = tmp;
        }
        bitString[position] = val;
    }
491968
def set_fraction(self, value):
        """"""
        if value < 0:
            value *= -1
        value = min(value, 1)
        if self.horizontal:
            width = int(self.width * value)
            height = self.height
        else:
            width = self.width
            height = int(self.height * value)
        self.canvas.coords(self.meter, self.xpos, self.ypos,
                           self.xpos + width, self.ypos + height)
473139
def configure(self, x0, axis):
        
        self.x0 = x0
        self.axis = axis