itla.itla12

   1from time import sleep
   2
   3from . import logger
   4from .itla import ITLABase
   5from .itla_errors import (
   6    CIEError,
   7    CPException,
   8    EREError,
   9    ExecutionError,
  10    NOPException,
  11    RVEError,
  12)
  13from .itla_status import (
  14    MCB,
  15    AlarmTrigger,
  16    FatalError,
  17    FatalTrigger,
  18    Resena,
  19    SQRTrigger,
  20    WarningError,
  21    Waveform,
  22)
  23
  24
  25class ITLA12(ITLABase):
  26    """
  27    A class that represents the ITLA12
  28    and exposes a user friendly API for controlling functionality.
  29
  30    Things to figure out
  31
  32    * What should be exposed to the user?
  33    * Can we abstract away the concept of registers and stuff
  34        in here so you don't have to deal with it.
  35
  36    There are some functions that could be implemented like set_fatalstatus.
  37    I think this is probably a bad idea even though it isnt write only.
  38
  39    Set Frequency is my platonic ideal for the higher level functions.
  40
  41    """
  42
  43    def __init__(
  44        self, serial_port, baudrate, timeout=0.5, register_files=None, sleep_time=0.1
  45    ):
  46        """Initializes the ITLA12 object.
  47
  48        :param serial_port: The serial port to connect to.
  49        Can either be linux/mac type such as '/dev/ttyUSBX' or windows type 'comX'
  50        :param baudrate: The baudrate for communication. I have primarily seen
  51        lasers using 9600 as the default and then higher for firmware upgrades.
  52        This may be laser specific.
  53        :param timeout: How long should we wait to receive a response from the laser
  54        :param register_files: Any additional register files you would like to include
  55        beyond the default MSA-01.2 defined registers. These must be in a yaml format as
  56        described in the project's README.
  57        :param sleep_time: time in seconds. Used in wait function
  58        """
  59        if register_files is None:
  60            register_files = []
  61
  62        register_files = ["registers_itla12.yaml", *register_files]
  63
  64        self.sleep_time = sleep_time
  65
  66        super().__init__(
  67            serial_port, baudrate, timeout=timeout, register_files=register_files
  68        )
  69
  70    def nop(self, data=None):
  71        """The No-Op operation.
  72
  73        This is a good test to see if your laser is communicating properly.
  74        It should read 0000 data or echo whatever data you send it if you send it something.
  75        The data you write to nop gets overwritten as soon as you read it back.
  76
  77        `nop()` also returns more informative errors following an ExecutionError.
  78        This is not called by default so you must do this explicitly if you want
  79        to see more informative error information.
  80
  81        See 9.4.1 NOP/Status (ResEna 0x00) [RW] in OIF-ITLA-MSA.
  82
  83        :param data: Data to write
  84
  85        :returns: None
  86        """
  87        # pretty sure the data does nothing
  88        if data is not None:
  89            response = self._nop(data)
  90        else:
  91            response = self._nop()
  92
  93        error_field = int(response.hex()[-1], 16)
  94        if bool(error_field):
  95            raise self._nop_errors[error_field]
  96
  97    def enable(self):
  98        """Enables laser optical output.
  99        There is a time delay after execution of this function to
 100        proper stable laser output.
 101
 102        See 9.6.3 Reset/Enable (ResEna 0x32) [RW]
 103
 104        :returns: None
 105        """
 106        # I'm writing this out partially for transparency
 107        # Maybe unnecessary or non-optimal
 108        self._resena(Resena.SENA)
 109
 110    def disable(self):
 111        """disables the laser
 112
 113        See 9.6.3 Reset/Enable (ResEna 0x32) [RW]
 114
 115        :returns: None
 116        """
 117        self._resena(0)
 118
 119    def hard_reset(self):
 120        """initiate module reset
 121
 122        The hardware reset is typically traffic interrupting since it will reset
 123        control loops as well. The host can poll the communication’s interface
 124        waiting for a response packet indicating that the interface is ready to
 125        communicate. Note that a response is returned to acknowledge the reset
 126        request before the reset is started
 127
 128        The impact to the optical signal is undefined. This bit is self clearing.
 129
 130        See 9.6.3 Reset/Enable (ResEna 0x32) [RW]
 131
 132        :returns: None
 133        """
 134        self._resena(Resena.MR)
 135
 136    def soft_reset(self):
 137        """initiate soft reset
 138
 139        The soft reset resets the communication’s interface and is traffic
 140        non-interrupting. Extended address registers are reset.
 141
 142        See 9.6.3 Reset/Enable (ResEna 0x32) [RW]
 143
 144        :returns: None
 145        """
 146        self._resena(Resena.SR)
 147
 148    def get_reset_enable(self):
 149        """return ResEna register.
 150
 151        See 9.6.3 Reset/Enable (ResEna 0x32) [RW]
 152        """
 153        response = self._resena()
 154        return Resena(int.from_bytes(response, "big"))
 155
 156    def set_alarm_during_tuning(self):
 157        """Set alarm during tuning
 158        mcb(ADT)
 159
 160        See 9.6.4 Module Configuration Behavior (MCB 0x33) [RW]
 161        """
 162        self._mcb(MCB.ADT)
 163
 164    def set_shutdown_on_fatal(self):
 165        """Set shutdown on fatal.
 166        mcb(SDF)
 167
 168        See 9.6.4 Module Configuration Behavior (MCB 0x33) [RW]
 169        """
 170        self._mcb(MCB.SDF)
 171
 172    def get_configuration_behavior(self):
 173        """
 174        Return MCB register.
 175
 176        See 9.6.4 Module Configuration Behavior (MCB 0x33) [RW]
 177        """
 178        response = self._mcb()
 179        return MCB(int.from_bytes(response, "big"))
 180
 181    def is_disabled(self):
 182        """
 183        Return if disabled.
 184
 185        See 9.6.3 Reset/Enable (ResEna 0x32) [RW] in OIF-ITLA-MSI.
 186
 187        For some lasers, FatalError.DIS is not triggered (even if TriggerT allows it).
 188        Consider overwriting this methods and monitoring FatalError.ALM.
 189        """
 190        fatal_error = self.get_error_fatal()
 191        fatal_trigger = self.get_fatal_trigger()
 192        resena = self.get_reset_enable()
 193        mcb = self.get_configuration_behavior()
 194
 195        sdf = MCB.SDF in mcb
 196        sena = Resena.SENA in resena
 197        dis = FatalError.DIS in fatal_error
 198
 199        return ((fatal_error & fatal_trigger) and sdf) or (not sena) or (not dis)
 200
 201    def is_enabled(self, *args):
 202        """
 203        Return if enabled.  See is_disabled.
 204        """
 205        return not self.is_disabled(*args)
 206
 207    def get_device_type(self):
 208        """returns a string containing the device type
 209
 210        DevTyp returns the module’s device type. For all tunable lasers covered by this MSA, the
 211        module will return the null terminated string “CW ITLA\0” (eight bytes including the
 212        terminating null character) indirectly through the AEA mechanism. The device type register
 213        is provided such that a host can distinguish between different types of tunable devices.type.
 214
 215        See 9.4.2 Device Type (DevTyp 0x01) [R]
 216        """
 217        response_bytes = self._devtyp()
 218
 219        return response_bytes.decode("utf-8")
 220
 221    def get_manufacturer(self):
 222        """returns a string containing the manufacturer's name.
 223
 224        MFGR returns the module’s manufacturers ID null terminated string indirectly through the
 225        AEA mechanism
 226
 227        See 9.4.3 Manufacturer (MFGR 0x02) [R]
 228        """
 229        response_bytes = self._mfgr()
 230
 231        return response_bytes.decode("utf-8")
 232
 233    def get_model(self):
 234        """returns the model as a string
 235
 236        Model returns the module’s model designation string indirectly through the AEA
 237        mechanism. The null terminated string containing the module’s model designation is
 238        placed into a field of not more than 80 bytes in size. The model string is defined by the
 239        manufacturer
 240
 241        See 9.4.4 Model (Model 0x03) [R]
 242        """
 243        response_bytes = self._model()
 244
 245        return response_bytes.decode("utf-8")
 246
 247    def get_serialnumber(self):
 248        """returns the serial number
 249
 250        SerNo returns the module’s serial number string indirectly through the AEA mechanism.
 251        The null terminated string containing the module’s serial number is placed into a field of not
 252        more than 80 bytes in size. The serial number string is defined by the manufacturer.
 253
 254        See 9.4.5 Serial Number (SerNo 0x04) [R]
 255        """
 256        response_bytes = self._serno()
 257
 258        return response_bytes.decode("utf-8")
 259
 260    def get_manufacturing_date(self):
 261        """returns the manufacturing date
 262
 263        MFGDate returns the manufacturing date string of the module indirectly through the AEA
 264        mechanism. The null terminated string containing the date string is contained in a field
 265        size of 12 bytes.
 266
 267        See 9.4.5 Manufaturing Date (MFGDate 0x05) [R]
 268        """
 269        response_bytes = self._mfgdate()
 270
 271        return response_bytes.decode("utf-8")
 272
 273    def get_firmware_release(self):
 274        """returns a manufacturer specific firmware release
 275
 276        Release returns the release string of the module indirectly through the AEA mechanism.
 277        The null terminated string containing the module release information is placed into a field of
 278        not more than 80 bytes in size. Note that a module may have one or more firmware and/or
 279        hardware revisions to track. The release field also encodes the application space
 280        identifier.
 281
 282        See 9.4.7 Release (Release 0x06) [R]
 283        """
 284        response_bytes = self._release()
 285
 286        return response_bytes.decode("utf-8")
 287
 288    def get_backwardscompatibility(self):
 289        """returns a manufacturer specific firmware backwards compatibility
 290        as a null terminated string
 291
 292        RelBack returns the release backwards compatibility string of the module indirectly through
 293        the AEA mechanism. The null terminated string containing the earliest release string which
 294        is fully backwards compatible with the current module. The string is contained in a field of
 295        not more than 80 bytes in size. Note that a module may have one or more firmware and/or
 296        hardware revisions to track as described in the Release (0x06) register
 297
 298        See 9.4.8 Release Backwards Compatibility (RelBack 0x07) [R]
 299        """
 300        response_bytes = self._relback()
 301
 302        return response_bytes.decode("utf-8")
 303
 304    def get_general_module_configuration(self):
 305        """returns the power on/reset module configuration
 306
 307        GenCfg defines the general module configuration for the generic tunable device. For the
 308        tunable laser, the register is used to save the power on/reset module configuration
 309        defaults.
 310
 311        See 9.4.9 General Module Configuration (GenCfg 0x08) [RW]
 312        """
 313        raise NotImplementedError()
 314
 315    def set_general_module_configuration(self):
 316        """returns the power on/reset module configuration
 317
 318        GenCfg defines the general module configuration for the generic tunable device. For the
 319        tunable laser, the register is used to save the power on/reset module configuration
 320        defaults.
 321
 322        See 9.4.9 General Module Configuration (GenCfg 0x08) [RW]
 323        """
 324        raise NotImplementedError()
 325
 326    def get_iocap(self):
 327        """
 328        The IOCap register returns or sets the I/O interface capabilities
 329
 330        See 9.4.10 IO Capabilities (IOCap 0x0D) [RW]
 331        """
 332        raise NotImplementedError()
 333
 334    def set_iocap(self, data):
 335        """
 336        The IOCap register returns or sets the I/O interface capabilities
 337
 338        See 9.4.10 IO Capabilities (IOCap 0x0D) [RW]
 339        """
 340        raise NotImplementedError()
 341
 342    def read_aea(self):
 343        """reads the AEA register data until an execution error is thrown.
 344
 345        See 9.4.11 Extended Addressing Mode Registers (0x09-0x0B, 0x0E-0x10) [RW]
 346        """
 347        aea_response = b""
 348        try:
 349            while True:
 350                aea_response += self._aea_ear()
 351
 352        except ExecutionError:
 353            try:
 354                self.nop()
 355
 356            except EREError:
 357                # If this throws an ERE error then we have completed reading AEA
 358                pass
 359
 360            except NOPException as nop_e:
 361                raise nop_e
 362
 363        return aea_response
 364
 365    def get_download_configuration(self):
 366        """
 367        The DLConfig register configures a host to module download of code or data for
 368        reconfiguration purposes or configures a module to host upload of code or data to the host.
 369        A file transfer may occur at several locations such as vendor factory, customer site (on the
 370        bench), customer system (circuit down), or potentially a customer system (live circuit)
 371
 372        See 9.4.13 Download Configuration (DLConfig 0x14) [RW]
 373        """
 374        raise NotImplementedError()
 375
 376    def set_download_configuration(self):
 377        """
 378        The DLConfig register configures a host to module download of code or data for
 379        reconfiguration purposes or configures a module to host upload of code or data to the host.
 380        A file transfer may occur at several locations such as vendor factory, customer site (on the
 381        bench), customer system (circuit down), or potentially a customer system (live circuit)
 382
 383        See 9.4.13 Download Configuration (DLConfig 0x14) [RW]
 384        """
 385        raise NotImplementedError()
 386
 387    def get_download_status(self):
 388        """
 389        DLStatus provides information about the status or viability of a code segment.
 390
 391        See 9.4.14 Download Status (DLStatus 0x15) [R]
 392        """
 393        raise NotImplementedError()
 394
 395    def wait(self):
 396        """Wait until operation is complete.
 397        It check if the operation is completed every self.sleep_time seconds.
 398        """
 399        while True:
 400            try:
 401                self.nop()
 402            except CPException:
 403                if self.sleep_time is not None:
 404                    sleep(self.sleep_time)
 405            else:
 406                break
 407
 408    def wait_until_enabled(self):
 409        """TODO: Add documentation."""
 410        while self.is_disabled():
 411            if self.sleep_time is not None:
 412                sleep(self.sleep_time)
 413
 414    def wait_until_disabled(self):
 415        """TODO: Add documentation."""
 416        while self.is_enabled():
 417            if self.sleep_time is not None:
 418                sleep(self.sleep_time)
 419
 420    def set_power(self, pwr_dBm):
 421        """Sets the power of the ITLA laser.
 422        Units of dBm.
 423
 424        See 9.6.2 Optical Power Set Point (PWR 0x31) [RW]
 425
 426        :param pwr_dBm: The power setting for the laser in dBm. Has precision XX.XX.
 427        :returns: None
 428        """
 429        try:
 430            self._pwr(round(pwr_dBm * 100))
 431
 432        except ExecutionError:
 433            try:
 434                self.nop()
 435
 436            except RVEError as error:
 437                logger.error(
 438                    "The provided power %.2f dBm is outside of the range for this device. "
 439                    "The power is currently set to: %.2f dBm.",
 440                    pwr_dBm,
 441                    self.get_power_setting(),
 442                )
 443                raise error
 444
 445    def get_power_setting(self):
 446        """Gets current power setting set by set_power.
 447        Should be in dBm.
 448
 449        See 9.6.2 Optical Power Set Point (PWR 0x31) [RW]
 450
 451        :returns:
 452        """
 453        # Gets power setting, not actual optical output power.
 454        response = self._pwr()
 455        return int.from_bytes(response, "big", signed=True) / 100
 456
 457    def get_power_output(self):
 458        """returns external optical power estimate
 459
 460        See 9.6.8 Optical Output Power (OOP 0x42) [R]
 461
 462        :returns: External optical power estimate in dBm
 463        """
 464        response = self._oop()
 465
 466        return int.from_bytes(response, "big", signed=True) / 100
 467
 468    def get_power_min(self):
 469        """returns minimum optical power output of the module.
 470        Units dBm.
 471
 472        See 9.7.2 Optical Power Min/Max Set Points (OPSL, OPSH 0x50 – 0x51) [R]
 473
 474        :returns: minimum optical power
 475        """
 476        response = self._opsl()
 477        return int.from_bytes(response, "big", signed=True) / 100
 478
 479    def get_power_max(self):
 480        """returns maximum optical power output of the module.
 481        Units dBm.
 482
 483        See 9.7.2 Optical Power Min/Max Set Points (OPSL, OPSH 0x50 – 0x51) [R]
 484
 485        :returns: maximum optical power
 486        """
 487        response = self._opsh()
 488        return int.from_bytes(response, "big", signed=True) / 100
 489
 490    def set_fcf(self, freq):
 491        """
 492        This sets the first channel frequency.
 493        It does not reset the channel so this frequency will only be equal
 494        to the output frequency if channel=1.
 495
 496        See 9.6.6 First Channel’s Frequency (FCF1, FCF2 0x35 – 0x36) [RW]
 497
 498        :returns: None
 499        """
 500        # convert frequency to MHz
 501        freq = round(freq * 1e6)
 502
 503        freq_str = str(freq)
 504        fcf1 = int(freq_str[0:3])
 505        fcf2 = int(freq_str[3:7])
 506
 507        try:
 508            # is it better to split these into their own try/except blocks?
 509            self._fcf1(fcf1)
 510            self._fcf2(fcf2)
 511
 512        except ExecutionError:
 513            try:
 514                self.nop()
 515            except RVEError as error:
 516                logger.error(
 517                    "%.2f THz is out of bounds for this laser. "
 518                    "The frequency must be within the range %.2f - %.2f THz.",
 519                    fcf1,
 520                    self.get_frequency_min(),
 521                    self.get_frequency_max(),
 522                )
 523                raise error
 524
 525            except CIEError as error:
 526                logger.error(
 527                    "You cannot change the first channel frequency while the laser is enabled. "
 528                    "The current frequency is: %.2f THz",
 529                    self.get_frequency(),
 530                )
 531                raise error
 532
 533    def set_frequency(self, freq):
 534        """Sets the frequency of the laser in TeraHertz.
 535
 536        Has MHz resolution. Will round down.
 537
 538        This function sets the first channel frequency and then sets the
 539        channel to 1 so that the frequency output when the laser is enabled
 540        will be the frequency given to this function.
 541
 542        If you would like to only change the first channel frequency use
 543        the function `set_fcf`.
 544
 545        Disable the laser before calling this function.
 546
 547        See 9.6.6 First Channel’s Frequency (FCF1, FCF2 0x35 – 0x36) [RW]
 548
 549        :param freq: The desired frequency setting in THz.
 550        :returns: None
 551        """
 552
 553        # This does a check so this only runs if fine tuning has been turned on.
 554        if self.get_fine_tuning() != 0:
 555            # Set the fine tuning off!
 556            while True:
 557                try:
 558                    self.set_fine_tuning(0)
 559                except ExecutionError:
 560                    sleep(self.sleep_time)
 561                except CPException:
 562                    self.wait()
 563                    break
 564                else:
 565                    break
 566
 567        try:
 568            self.set_fcf(freq)
 569        except CPException:
 570            self.wait()
 571
 572        try:
 573            self.set_channel(1)
 574        except CPException:
 575            self.wait()
 576
 577    def get_fcf(self):
 578        """returns first channel frequency
 579
 580        See 9.6.6 First Channel’s Frequency (FCF1, FCF2 0x35 – 0x36) [RW]
 581
 582        :returns: First channel frequency in THz
 583        """
 584        response = self._fcf1()
 585        fcf1 = int.from_bytes(response, "big")
 586
 587        response = self._fcf2()
 588        fcf2 = int.from_bytes(response, "big")
 589
 590        return fcf1 + fcf2 * 1e-4
 591
 592    def get_frequency(self):
 593        """gets the current laser operating frequency
 594
 595        See 9.6.7 Laser Frequency (LF1, LF2 0x40 – 0x41) [R]
 596
 597        :returns: Current laser frequency in THz.
 598        """
 599        response = self._lf1()
 600        lf1 = int.from_bytes(response, "big")
 601
 602        response = self._lf2()
 603        lf2 = int.from_bytes(response, "big")
 604
 605        return lf1 + lf2 * 1e-4
 606
 607    def dither_enable(self, waveform: Waveform = Waveform.SIN):
 608        """enables dither
 609
 610        See 9.8.3 Digital Dither (Dither(E,R,A,F) 0x59-0x5C) [RW] [Optional]
 611
 612        :param waveform: specifies the dither waveform
 613        """
 614
 615        data = (waveform << 4) | 2
 616
 617        self._dithere(data)
 618
 619    def dither_disable(self):
 620        """disables digital dither
 621
 622        See 9.8.3 Digital Dither (Dither(E,R,A,F) 0x59-0x5C) [RW] [Optional]
 623        """
 624        # TODO: This should preserve the waveform setting if possible
 625        self._dithere(0)
 626
 627    def set_dither_rate(self, rate):
 628        """set dither rate in kHz
 629        utilizes DitherR register
 630
 631        See 9.8.3 Digital Dither (Dither(E,R,A,F) 0x59-0x5C) [RW] [Optional]
 632
 633        :param rate: an unsigned short integer specifying dither rate in kHz
 634        """
 635        self._ditherr(rate)
 636
 637    def get_dither_rate(self):
 638        """get dither rate
 639        utilizes DitherR register
 640
 641        See 9.8.3 Digital Dither (Dither(E,R,A,F) 0x59-0x5C) [RW] [Optional]
 642
 643        :returns: Dither rate in kHz
 644        """
 645        response = self._ditherr()
 646        return int.from_bytes(response, "big")
 647
 648    def set_dither_frequency(self, rate):
 649        """set dither modulation frequency
 650        utilizes DitherF register
 651
 652        See 9.8.3 Digital Dither (Dither(E,R,A,F) 0x59-0x5C) [RW] [Optional]
 653
 654        :param rate: an unsigned short integer encoded as the FM peak-to-peak frequency
 655        deviation as Ghz*10
 656        """
 657        self._ditherf(rate)
 658
 659    def get_dither_frequency(self):
 660        """get dither modulation frequency
 661        utilizes DitherF register
 662
 663        See 9.8.3 Digital Dither (Dither(E,R,A,F) 0x59-0x5C) [RW] [Optional]
 664
 665        :returns: dither modulation frequency in GHz * 10
 666        """
 667        response = self._ditherf()
 668        return int.from_bytes(response, "big")
 669
 670    def set_dither_amplitude(self, amplitude):
 671        """set dither modulation amplitude
 672        utilizes DitherA register
 673
 674        See 9.8.3 Digital Dither (Dither(E,R,A,F) 0x59-0x5C) [RW] [Optional]
 675
 676        :param amplitude: an unsigned short integer encoded as the AM peak-to-peak amplitude
 677        deviation as 10*percentage of the optical power
 678
 679        :returns: None
 680        """
 681        self._dithera(amplitude)
 682
 683    def get_dither_amplitude(self):
 684        """get dither modulation amplitude
 685        utilizes DitherA register
 686
 687        See 9.8.3 Digital Dither (Dither(E,R,A,F) 0x59-0x5C) [RW] [Optional]
 688
 689        :returns: dither aplitude in 10ths of percents
 690        """
 691        response = self._dithera()
 692        return int.from_bytes(response, "big")
 693
 694    def get_temp(self):
 695        """Returns the current primary control temperature in deg C.
 696
 697        See 9.6.9 Current Temperature (CTemp 0x43) [R]
 698
 699        :returns: current primary control temperature in deg C
 700        """
 701        response = self._ctemp()
 702        temp_100 = int.from_bytes(response, "big")
 703
 704        return temp_100 / 100
 705
 706    def get_frequency_min(self):
 707        """returns minimum frequency supported by the module
 708
 709        See 9.7.3 Laser’s First/Last Frequency (LFL1/2, LFH1/2 0x52-0x55) [R]
 710
 711        :returns: minimum frequency in THz
 712        """
 713        response = self._lfl1()
 714        lfl1 = int.from_bytes(response, "big")
 715
 716        response = self._lfl2()
 717        lfl2 = int.from_bytes(response, "big")
 718
 719        return lfl1 + lfl2 * 1e-4
 720
 721    def get_frequency_max(self):
 722        """returns maximum frequency supported by the module
 723
 724        See 9.7.3 Laser’s First/Last Frequency (LFL1/2, LFH1/2 0x52-0x55) [R]
 725
 726        :returns: maximum frequency in THz
 727        """
 728        response = self._lfh1()
 729        fcf1 = int.from_bytes(response, "big")
 730
 731        response = self._lfh2()
 732        fcf2 = int.from_bytes(response, "big")
 733
 734        return fcf1 + fcf2 * 1e-4
 735
 736    def get_grid_min(self):
 737        """returns minimum grid spacing of the module
 738
 739        See 9.7.4 Laser’s Minimum Grid Spacing (LGrid 0x56) [R]
 740
 741        :returns: The minimum grid supported by the module in GHz
 742        """
 743        try:
 744            freq_lgrid = int.from_bytes(self._lgrid(), "big", signed=False)
 745
 746        except ExecutionError:
 747            self.nop()
 748
 749        return freq_lgrid * 1e-1
 750
 751    def set_grid(self, grid_freq):
 752        """Set the grid spacing in GHz.
 753        MHz resolution.
 754
 755        See 9.6.5 Grid Spacing (Grid 0x34) [RW]
 756
 757        :param grid_freq: the grid frequency spacing in GHz
 758        :returns:
 759
 760        """
 761        grid_freq = str(round(grid_freq * 1000))
 762        data = int(grid_freq[0:4])
 763
 764        self._grid(data)
 765
 766    def get_grid(self):
 767        """get the grid spacing in GHz
 768
 769        See 9.6.5 Grid Spacing (Grid 0x34) [RW]
 770
 771        :returns: The grid spacing in GHz.
 772        """
 773        response = self._grid()
 774        grid_freq = int.from_bytes(response, "big", signed=True)
 775
 776        return grid_freq * 1e-1
 777
 778    def get_age(self):
 779        """Returns the percentage of aging of the laser.
 780        0% indicated a brand new laser
 781        100% indicates the laser should be replaces.
 782
 783        See 9.8.6 Laser Age (Age 0x61) [R]
 784
 785        :returns: percent aging of the laser
 786        """
 787        response = self._age()
 788        age = int.from_bytes(response, "big")
 789
 790        return age
 791
 792    def set_channel(self, channel):
 793        """Sets the laser's operating channel.
 794
 795        MSA-01.2 lasers support a 16 bit channel value.
 796
 797        This defines how many spaces along the grid
 798        the laser's frequency is displaced from the first channel frequency.
 799
 800        See 9.6.1 Channel (Channel 0x30) [RW]
 801
 802        :param channel:
 803        :returns: None
 804
 805        """
 806        # check type and stuff
 807        if not isinstance(channel, int):
 808            raise TypeError("Channel must be an integer")
 809        if channel < 0:
 810            raise ValueError("Channel must be positive.")
 811        if channel > 0xFFFF:
 812            raise ValueError("Channel must be a 16 bit integer (<=0xFFFF).")
 813
 814        # Split the channel choice into two options.
 815        channel_hex = f"{channel:08x}"
 816
 817        channell = int(channel_hex[4:], 16)
 818
 819        # Set the channel registers.
 820        self._channel(channell)
 821
 822    def get_channel(self):
 823        """gets the current channel setting
 824
 825        The channel defines how many spaces along the grid
 826        the laser's frequency is displaced from the first channel frequency.
 827
 828        See 9.6.1 Channel (Channel 0x30) [RW]
 829
 830        :returns: channel as an integer.
 831
 832        """
 833        # This concatenates the data bytestrings
 834        response = self._channel()
 835
 836        channel = int.from_bytes(response, "big")
 837
 838        return channel
 839
 840    def set_fine_tuning(self, ftf):
 841        """
 842        This function provides off grid tuning for the laser's frequency.
 843        The adjustment applies to all channels uniformly.
 844        This is typically used after the laser if locked and minor adjustments
 845        are required to the frequency.
 846
 847        The command may be pending in the event that the laser output is
 848        enabled. The pending bit is cleared once the fine tune frequency
 849        has been achieved.
 850
 851        See 9.8.7 Fine Tune Frequency (FTF 0x62) [RW]
 852
 853        **???** It seems like this can be done with the laser running.
 854
 855        :param ftf: The fine tune frequency adjustment in GHz
 856        """
 857
 858        ftf = round(ftf * 1e3)
 859
 860        # We will leave this bare. This way the user can set and handle
 861        # their own timing and check to make sure the laser has reached the
 862        # desired fine tuning frequency.
 863        # It WILL throw a "pending" error if the laser is on when setting.
 864        self._ftf(ftf)
 865
 866    def get_fine_tuning(self):
 867        """
 868        This function returns the setting for the
 869        off grid tuning for the laser's frequency.
 870
 871        See 9.8.7 Fine Tune Frequency (FTF 0x62) [RW]
 872
 873        :return ftf: The fine tune frequency adjustment in GHz
 874        """
 875
 876        response = self._ftf()
 877        ftf = int.from_bytes(response, "big", signed=True)
 878
 879        return ftf * 1e-3
 880
 881    def get_ftf_range(self):
 882        """return the maximum and minimum off grid tuning for the laser's frequency.
 883
 884        See 9.7.1 Fine Tune Frequency Range (FTF 0x4F) [R]
 885
 886        :return ftfr: The fine tune frequency range [-ftfr, + ftfr] in GHz
 887        """
 888        response = self._ftfr()
 889
 890        ftfr = int.from_bytes(response, "big")
 891
 892        return ftfr * 1e-3
 893
 894    def get_temps(self):
 895        """returns a list of technology specific temperatures
 896        units in deg C unless otherwise specified
 897
 898        **Technologies**
 899        Technology 1: [Diode Temp, Case Temp]
 900        Technology 2: [Diode Temp, Case Temp]
 901        (why are they the same?)
 902
 903        See 9.8.2 Module Temperatures (Temps 0x58) [R]
 904
 905        :returns: list of temperatures in deg C
 906        """
 907        # get response this should be a long byte string
 908        response = self._temps()
 909
 910        data = [
 911            int.from_bytes(response[i : i + 2], "big", signed=True) / 100
 912            for i in range(0, len(response), 2)
 913        ]
 914
 915        return data
 916
 917    def get_currents(self):
 918        """returns a list of technology specific currents in mA.
 919
 920        **Technologies**
 921        Technology 1: [TEC, Diode]
 922        Technology 2: [TED, Diode 1, Diode 2, Diode 3, Diode 4, SOA]
 923        Technology 3: [TEC, Diode 1, tbd, tbd, tbd, ...]
 924
 925        See 9.8.1 Module Currents (Currents 0x57) [R]
 926
 927        :returns: list of currents in mA
 928        """
 929        # get response this should be a long byte string
 930        response = self._currents()
 931
 932        data = [
 933            int.from_bytes(response[i : i + 2], "big", signed=True) / 10
 934            for i in range(0, len(response), 2)
 935        ]
 936
 937        return data
 938
 939    def get_last_response(self):
 940        """reads the last response sent from the laser
 941
 942        This function gets the most recent response sent from the laser.
 943        The response is parsed for errors the way any normal response
 944        would be. The variable `self._response` is set to the last response again.
 945
 946        See 9.4.12 Last Response (LstResp 0x13) [R]
 947
 948        """
 949        return self._lstresp()
 950
 951    def get_error_fatal(self, reset=False):
 952        """reads fatal error register statusf and checks each bit against the
 953        fatal error table to determine the fault
 954
 955        See 9.5.1 StatusF, StatusW (0x20, 0x21) [RW]
 956
 957        :param reset: resets/clears latching errors
 958
 959        """
 960        response = self._statusf()
 961        statusf = int.from_bytes(response, "big")
 962
 963        logger.debug("Current Status Fatal Error: %d", statusf)
 964
 965        if reset:
 966            data_reset = 0x00FF
 967            self._statusf(data_reset)
 968
 969        return FatalError(statusf)
 970
 971    def get_error_warning(self, reset=False):
 972        """reads warning error register statusw and checks each bit against the
 973        warning error table to determine the fault
 974
 975        If the laser is off then some of the latched warnings will be set on.
 976
 977        See 9.5.1 StatusF, StatusW (0x20, 0x21) [RW]
 978
 979        :param reset: resets/clears latching errors
 980        """
 981        response = self._statusw()
 982        statusw = int.from_bytes(response, "big")
 983
 984        logger.debug("Current Status Warning Error: %d", statusw)
 985
 986        if reset:
 987            data_reset = 0x00FF
 988            self._statusw(data_reset)
 989
 990        return WarningError(statusw)
 991
 992    def get_fatal_power_thresh(self):
 993        """reads maximum plus/minus power deviation in dB for which the fatal alarm is asserted
 994
 995        See 9.5.2 Power Threshold (FPowTh, WPowTh 0x22, 0x23) [RW]
 996        """
 997        response = self._fpowth()
 998        pow_fatal = int.from_bytes(response, "big") / 100
 999        # correcting for proper order of magnitude
1000        return pow_fatal
1001
1002    def get_warning_power_thresh(self):
1003        """reads maximum plus/minus power deviation in dB for which the warning alarm is asserted
1004
1005        See 9.5.2 Power Threshold (FPowTh, WPowTh 0x22, 0x23) [RW]
1006        """
1007        response = self._wpowth()
1008        pow_warn = int.from_bytes(response, "big") / 100
1009        # correcting for proper order of magnitude
1010        return pow_warn
1011
1012    def get_fatal_freq_thresh(self):
1013        """reads maximum plus/minus frequency deviation in GHz for which the fatal alarm is asserted
1014
1015        See 9.5.3 Frequency Threshold (FFreqTh, WFreqTh 0x24, 0x25) [RW]
1016        """
1017        response = self._ffreqth()
1018        freq_fatal = int.from_bytes(response, "big") / 10
1019        return freq_fatal
1020
1021    def get_warning_freq_thresh(self):
1022        """reads maximum plus/minus frequency deviation in GHz for which the warning alarm is asserted
1023
1024        See 9.5.3 Frequency Threshold (FFreqTh, WFreqTh 0x24, 0x25) [RW]
1025        """
1026        response = self._wfreqth()
1027        freq_warn = int.from_bytes(response, "big") / 10
1028        return freq_warn
1029
1030    def get_fatal_therm_thresh(self):
1031        """reads maximum plus/minus thermal deviation in degree celcius for which the fatal alarm is asserted
1032
1033        See 9.5.4 Thermal Threshold (FThermTh, WThermTh 0x26, 0x27) [RW]
1034        """
1035        response = self._fthermth()
1036        therm_fatal = int.from_bytes(response, "big") / 100
1037        # correcting for proper order of magnitude
1038        return therm_fatal
1039
1040    def get_warning_therm_thresh(self):
1041        """reads maximum plus/minus thermal deviation in degree celcius for which the warning alarm is asserted
1042
1043        See 9.5.4 Thermal Threshold (FThermTh, WThermTh 0x26, 0x27) [RW]
1044        """
1045        response = self._wthermth()
1046        therm_thresh = int.from_bytes(response, "big") / 100
1047        # correcting for proper order of magnitude
1048        return therm_thresh
1049
1050    def get_srq_trigger(self):
1051        """identifies corresponding bits in status registers StatusF, StatusW
1052
1053        Utilizes SRQT register to identify why SRQ was asserted in StatusF and StatusW registers
1054
1055        See 9.5.5 SRQ* Triggers (SRQT 0x28) [RW]
1056        """
1057        response = self._srqt()
1058        status = int.from_bytes(response, "big")
1059
1060        logger.debug("SRQT Status: %d", status)
1061
1062        return SQRTrigger(status)
1063
1064    def get_fatal_trigger(self):
1065        """identifies which fatal condition was asserted in StatusF and StatusW registers
1066
1067        See 9.5.6 FATAL Triggers (FatalT 0x29) [RW]
1068        """
1069        response = self._fatalt()
1070        status = int.from_bytes(response, "big")
1071
1072        logger.debug("FatalT Status: %d", status)
1073
1074        return FatalTrigger(status)
1075
1076    def get_alm_trigger(self):
1077        """identifies why ALM was asserted in StatusF and StatusW registers
1078
1079        See 9.5.7 ALM Triggers (ALMT 0x2A) [RW]
1080        """
1081        response = self._almt()
1082        status = int.from_bytes(response, "big")
1083
1084        logger.debug("AlarmT Status: %d", status)
1085
1086        return AlarmTrigger(status)