class SR2(SeaBreezeDevice):
    model_name = "SR2"

    # communication config
    transport = (USBTransport,)
    usb_vendor_id = 0x0999
    usb_product_id = 0x1001
    usb_endpoint_map = EndPointMap(ep_out=0x01, highspeed_in=0x81)
    usb_protocol = OBP2Protocol

    # spectrometer config
    dark_pixel_indices = DarkPixelIndices.from_ranges((0,24))
    integration_time_min = 1  # 1 us
    integration_time_max = 2000000  # 2 s
    integration_time_base = 1
    spectrum_num_pixel = 2110
    spectrum_raw_length = (2110 * 2) + 32  # Metadata
    spectrum_max_value = 65535
    trigger_modes = TriggerMode.supported("OBP_NORMAL")

    # features
    feature_classes = (sbf.spectrometer.SeaBreezeSpectrometerFeatureSR2,)

class SeaBreezeSpectrometerFeatureSR2(SeaBreezeSpectrometerFeatureOBP):

    def _get_spectrum_raw(self) -> NDArray[np.uint8]:
        timeout = int(
            self._integration_time_max * 1e-3
            + self.protocol.transport.default_timeout_ms
        )
        datastring = self.protocol.query(0x000_01C_00, timeout_ms=timeout)  
        return numpy.frombuffer(datastring, dtype=numpy.uint8)  # type: ignore

    def get_intensities(self) -> NDArray[np.float_]:
        tmp = self._get_spectrum_raw()
        # 32byte metadata block at beginning
        ret = numpy.array(
            struct.unpack("<" + "H" *self._spectrum_length, tmp[32:]),
            dtype=numpy.double,
        )
        return ret * self._normalization_value

    def set_trigger_mode(self, mode: int) -> None:
        if mode in self._trigger_modes:
            self.protocol.send(0x000_00D_01, mode, request_ack=True)  
        else:
            raise SeaBreezeError("Only supports: %s" % str(self._trigger_modes))

    def set_integration_time_micros(self, integration_time_micros: int) -> None:
        t_min = self._integration_time_min
        t_max = self._integration_time_max
        if t_min <= integration_time_micros < t_max:
            i_time = int(integration_time_micros / self._integration_time_base)
            self.protocol.send(0x000_00C_01, i_time)  
        else:
            raise SeaBreezeError(f"Integration not in [{t_min:d}, {t_max:d}]")

    def get_wavelengths(self) -> NDArray[np.float_]:
        data = self.protocol.query(0x000_011_00)  
        num_coeffs = len(data) // 4
        assert len(data) % 4 == 0  # ???
        assert num_coeffs > 1  # ???
        coeffs = struct.unpack("<" + "f" * num_coeffs, data)[1:]
        # and generate the wavelength array
        indices = numpy.arange(self._spectrum_length, dtype=numpy.float64)
        return sum(wl * (indices**i) for i, wl in enumerate(coeffs))  # type: ignore