itla.itla13

  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 ITLA13(ITLABase):
 26    """
 27    A class that represents the ITLA13
 28    and exposes a user friendly API for controlling functionality.
 29
 30    OIF-ITLA-MSA-01.3 is the standard implemented here.
 31    Certain functions such as set_frequency() dont fully implement this yet
 32    because I dont know how to do checks to see if the optional FCF3
 33    functions are implemented for a particular laser.
 34
 35    Things to figure out
 36
 37      * What should be exposed to the user?
 38      * Can we abstract away the concept of registers and stuff
 39        in here so you don't have to deal with it.
 40
 41    There are some functions that could be implemented like set_fatalstatus.
 42    I think this is probably a bad idea even though it isnt write only.
 43
 44    Set Frequency is my platonic ideal for the higher level functions.
 45
 46    """
 47
 48    def __init__(
 49        self, serial_port, baudrate, timeout=0.5, register_files=None, sleep_time=0.1
 50    ):
 51        """Initializes the ITLA12 object.
 52
 53        :param serial_port: The serial port to connect to.
 54        Can either be linux/mac type such as '/dev/ttyUSBX' or windows type 'comX'
 55        :param baudrate: The baudrate for communication. I have primarily seen
 56        lasers using 9600 as the default and then higher for firmware upgrades.
 57        This may be laser specific.
 58        :param timeout: How long should we wait to receive a response from the laser
 59        :param register_files: Any additional register files you would like to include
 60        beyond the default MSA-01.3 defined registers. These must be in a yaml format as
 61        described in the project's README.
 62        :param sleep_time: time in seconds. Use in wait function
 63        """
 64        if register_files is None:
 65            register_files = []
 66
 67        register_files = ["registers_itla12.yaml", *register_files]
 68
 69        self.sleep_time = sleep_time
 70
 71        super().__init__(
 72            serial_port, baudrate, timeout=timeout, register_files=register_files
 73        )
 74
 75    def nop(self, data=None):
 76        """The No-Op operation.
 77
 78        This is a good test to see if your laser is communicating properly.
 79        It should read 0000 data or echo whatever data you send it if you send it something.
 80        The data you write to nop gets overwritten as soon as you read it back.
 81
 82        `nop()` also returns more informative errors following an ExecutionError.
 83        This is not called by default so you must do this explicitly if you want
 84        to see more informative error information.
 85
 86        :param data: Data to write
 87
 88        """
 89        # pretty sure the data does nothing
 90        if data is not None:
 91            response = self._nop(data)
 92        else:
 93            response = self._nop()
 94
 95        error_field = int(response.hex()[-1], 16)
 96        if bool(error_field):
 97            raise self._nop_errors[error_field]
 98
 99    def enable(self):
100        """Enables laser optical output.
101        There is a time delay after execution of this function to
102        proper stable laser output.
103
104        :returns: None
105
106        """
107        # I'm writing this out partially for transparency
108        # Maybe unnecessary or non-optimal
109        self._resena(Resena.SENA)
110
111    def disable(self):
112        """Tells the laser to stop lasing.
113
114        :returns: None
115
116        """
117        self._resena(0)
118
119    def hard_reset(self):
120        """TODO describe function
121
122        :returns:
123
124        """
125        self._resena(Resena.MR)
126
127    def soft_reset(self):
128        """TODO describe function
129
130        :returns:
131
132        """
133        self._resena(Resena.SR)
134
135    def get_reset_enable(self):
136        """
137        Return ResEna register.
138        """
139        response = self._resena()
140        return Resena(int.from_bytes(response, "big"))
141
142    def set_alarm_during_tuning(self):
143        """Set alarm during tuning
144        mcb(ADT)
145        """
146        self._mcb(MCB.ADT)
147
148    def set_shutdown_on_fatal(self):
149        """Set shutdown on fatal.
150        mcb(SDF)
151        """
152        self._mcb(MCB.SDF)
153
154    def get_configuration_behavior(self):
155        """
156        Return MCB register.
157        """
158        response = self._mcb()
159        return MCB(int.from_bytes(response, "big"))
160
161    def is_disabled(self):
162        """
163        Return if disabled.
164
165        See 9.6.3 Reset/Enable (ResEna 0x32) [RW] in OIF-ITLA-MSI.
166
167        For some lasers, FatalError.DIS is not triggered (even if TriggerT allows it).
168        Consider overwriting this methods and monitoring FatalError.ALM.
169        """
170        fatal_error = self.get_error_fatal()
171        fatal_trigger = self.get_fatal_trigger()
172        resena = self.get_reset_enable()
173        mcb = self.get_configuration_behavior()
174
175        sdf = MCB.SDF in mcb
176        sena = Resena.SENA in resena
177        dis = FatalError.DIS in fatal_error
178
179        return ((fatal_error & fatal_trigger) and sdf) or (not sena) or (not dis)
180
181    def is_enabled(self, *args):
182        """
183        Return if enabled.  See is_disabled.
184        """
185        return not self.is_disabled(*args)
186
187    def get_device_type(self):
188        """
189        returns a string containing the device type.
190        """
191        response_bytes = self._devtyp()
192
193        return response_bytes.decode("utf-8")
194
195    def get_manufacturer(self):
196        """
197        Return's a string containing the manufacturer's name.
198        """
199        response_bytes = self._mfgr()
200
201        return response_bytes.decode("utf-8")
202
203    def get_model(self):
204        """
205        return's the model as a string
206        """
207        response_bytes = self._model()
208
209        return response_bytes.decode("utf-8")
210
211    def get_serialnumber(self):
212        """
213        returns the serial number
214        """
215        response_bytes = self._serno()
216
217        return response_bytes.decode("utf-8")
218
219    def get_manufacturing_date(self):
220        """returns the manufacturing date"""
221        response_bytes = self._mfgdate()
222
223        return response_bytes.decode("utf-8")
224
225    def get_firmware_release(self):
226        """
227        returns a manufacturer specific firmware release
228        """
229        response_bytes = self._release()
230
231        return response_bytes.decode("utf-8")
232
233    def get_backwardscompatibility(self):
234        """
235        returns a manufacturer specific firmware backwards compatibility
236        as a null terminated string
237        """
238        response_bytes = self._relback()
239
240        return response_bytes.decode("utf-8")
241
242    def read_aea(self):
243        """
244        reads the AEA register data until an execution error is thrown.
245        """
246        aea_response = b""
247        try:
248            while True:
249                aea_response += self._aea_ear()
250
251        except ExecutionError:
252            try:
253                self.nop()
254
255            except EREError:
256                # If this throws an ERE error then we have completed reading AEA
257                pass
258
259            except NOPException as nop_e:
260                raise nop_e
261
262        return aea_response
263
264    def wait(self):
265        """Wait until operation is complete. It check if the operation is completed every self.sleep_time seconds."""
266        while True:
267            try:
268                self.nop()
269            except CPException:
270                if self.sleep_time is not None:
271                    sleep(self.sleep_time)
272            else:
273                break
274
275    def wait_until_enabled(self):
276        while self.is_disabled():
277            if self.sleep_time is not None:
278                sleep(self.sleep_time)
279
280    def wait_until_disabled(self):
281        while self.is_enabled():
282            if self.sleep_time is not None:
283                sleep(self.sleep_time)
284
285    def set_power(self, pwr_dBm):
286        """Sets the power of the ITLA laser. Units of dBm.
287
288        :param pwr_dBm: The power setting for the laser in dBm. Has precision XX.XX.
289        :returns: None
290
291        """
292        try:
293            self._pwr(round(pwr_dBm * 100))
294
295        except ExecutionError:
296            try:
297                self.nop()
298
299            except RVEError as error:
300                logger.error(
301                    "The provided power %.2f dBm is outside of the range for this device. "
302                    "The power is currently set to: %.2f dBm.",
303                    pwr_dBm,
304                    self.get_power_setting(),
305                )
306                raise error
307
308    def get_power_setting(self):
309        """Gets current power setting set by set_power. Should be in dBm.
310
311        :returns:
312
313        """
314        # Gets power setting, not actual optical output power.
315        response = self._pwr()
316        return int.from_bytes(response, "big", signed=True) / 100
317
318    def get_power_output(self):
319        """Gets the actual optical output power of the laser.
320        Only an approximation, apparently. Units dBm.
321
322        :returns:
323
324        """
325        response = self._oop()
326
327        return int.from_bytes(response, "big", signed=True) / 100
328
329    def get_power_min(self):
330        """Gets the minimum optical power output of the module. Units dBm.
331
332        :returns:
333
334        """
335        response = self._opsl()
336        return int.from_bytes(response, "big", signed=True) / 100
337
338    def get_power_max(self):
339        """Gets the maximum optical power output of the module. Units dBm.
340
341        :returns:
342
343        """
344        response = self._opsh()
345        return int.from_bytes(response, "big", signed=True) / 100
346
347    def set_fcf(self, freq):
348        """
349        This sets the first channel frequency.
350        It does not reset the channel so this frequency will only be equal
351        to the output frequency if channel=1.
352
353        """
354        # convert frequency to MHz
355        freq = round(freq * 1e6)
356
357        freq_str = str(freq)
358        fcf1 = int(freq_str[0:3])
359        fcf2 = int(freq_str[3:7])
360        fcf3 = int(freq_str[7:])
361
362        try:
363            # is it better to split these into their own try/except blocks?
364            self._fcf1(fcf1)
365            self._fcf2(fcf2)
366            self._fcf3(fcf3)
367
368        except ExecutionError:
369            try:
370                self.nop()
371            except RVEError as error:
372                logger.error(
373                    "%.2f THz is out of bounds for this laser. "
374                    "The frequency must be within the range %.2f - %.2f THz.",
375                    fcf1,
376                    self.get_frequency_min(),
377                    self.get_frequency_max(),
378                )
379                raise error
380
381            except CIEError as error:
382                logger.error(
383                    "You cannot change the first channel frequency while the laser is enabled. "
384                    "The current frequency is: %.2f THz",
385                    self.get_frequency(),
386                )
387                raise error
388
389    def set_frequency(self, freq):
390        """Sets the frequency of the laser in TeraHertz.
391
392        Has MHz resolution. Will round down.
393
394        This function sets the first channel frequency and then sets the
395        channel to 1 so that the frequency output when the laser is enabled
396        will be the frequency given to this function.
397
398        If you would like to only change the first channel frequency use
399        the function `set_fcf`.
400
401        Disable the laser before calling this function.
402
403        :param freq: The desired frequency setting in THz.
404        :returns: None
405        """
406        # This does a check so this only runs if fine tuning has been turned on.
407        if self.get_fine_tuning() != 0:
408            # Set the fine tuning off!
409            while True:
410                try:
411                    self.set_fine_tuning(0)
412                except ExecutionError:
413                    sleep(self.sleep_time)
414                except CPException:
415                    self.wait()
416                    break
417                else:
418                    break
419
420        try:
421            self.set_fcf(freq)
422        except CPException:
423            self.wait()
424
425        try:
426            self.set_channel(1)
427        except CPException:
428            self.wait()
429
430    def get_fcf(self):
431        """Get the currently set first channel frequency."""
432        response = self._fcf1()
433        fcf1 = int.from_bytes(response, "big")
434
435        response = self._fcf2()
436        fcf2 = int.from_bytes(response, "big")
437
438        response = self._fcf3()
439        fcf3 = int.from_bytes(response, "big")
440
441        return fcf1 + fcf2 * 1e-4 + fcf3 * 1e-6
442
443    def get_frequency(self):
444        """gets the current laser operating frequency with channels
445        and everything accounted for.
446
447        :returns:
448
449        """
450        response = self._lf1()
451        lf1 = int.from_bytes(response, "big")
452
453        response = self._lf2()
454        lf2 = int.from_bytes(response, "big")
455
456        response = self._lf3()
457        lf3 = int.from_bytes(response, "big")
458
459        return lf1 + lf2 * 1e-4 + lf3 * 1e-6
460
461    def dither_enable(self, waveform: Waveform = Waveform.SIN):
462        """enables dither
463
464        See 9.8.3 Digital Dither (Dither(E,R,A,F) 0x59-0x5C) [RW] [Optional]
465
466        :param waveform: specifies the dither waveform
467        """
468        data = (waveform << 4) | 2
469
470        self._dithere(data)
471
472    def dither_disable(self):
473        """disables digital dither"""
474        # TODO: This should preserve the waveform setting if possible
475        self._dithere(0)
476
477    def set_dither_rate(self, rate):
478        """
479        set dither rate in kHz, utilizes DitherR register
480        :param rate: an unsigned short integer specifying dither rate in kHz
481        """
482        self._ditherr(rate)
483
484    def get_dither_rate(self):
485        """
486        get dither rate, utilizes DitherR register
487        """
488        response = self._ditherr()
489        return int.from_bytes(response, "big")
490
491    def set_dither_frequency(self, rate):
492        """
493        set dither modulation frequency, utilizes DitherF register
494        :param rate: an unsigned short integer encoded as the FM peak-to-peak frequency
495        deviation as Ghz*10
496        """
497        self._ditherf(rate)
498
499    def get_dither_frequency(self):
500        """
501        get dither modulation frequency, utilizes DitherF register
502        """
503        response = self._ditherf()
504        return int.from_bytes(response, "big")
505
506    def set_dither_amplitude(self, amplitude):
507        """
508        set dither modulation amplitude, utilizes DitherA register
509        :param amplitude: an unsigned short integer encoded as the AM peak-to-peak amplitude
510        deviation as 10*percentage of the optical power
511        """
512        self._dithera(amplitude)
513
514    def get_dither_amplitude(self):
515        """
516        get dither modulation amplitude, utilizes DitherA register
517        """
518        response = self._dithera()
519        return int.from_bytes(response, "big")
520
521    def get_temp(self):
522        """Returns the current primary control temperature in deg C.
523
524        :returns:
525
526        """
527        response = self._ctemp()
528        temp_100 = int.from_bytes(response, "big")
529
530        return temp_100 / 100
531
532    def get_frequency_min(self):
533        """command to read minimum frequency supported by the module
534
535        :returns:
536
537        """
538        response = self._lfl1()
539        lfl1 = int.from_bytes(response, "big")
540
541        response = self._lfl2()
542        lfl2 = int.from_bytes(response, "big")
543
544        response = self._lfl3()
545        lfl3 = int.from_bytes(response, "big")
546
547        return lfl1 + lfl2 * 1e-4 + lfl3 * 1e-6
548
549    def get_frequency_max(self):
550        """command to read maximum frequency supported by the module
551
552        :returns:
553
554        """
555        response = self._lfh1()
556        fcf1 = int.from_bytes(response, "big")
557
558        response = self._lfh2()
559        fcf2 = int.from_bytes(response, "big")
560
561        response = self._lfh3()
562        fcf3 = int.from_bytes(response, "big")
563
564        return fcf1 + fcf2 * 1e-4 + fcf3 * 1e-6
565
566    def get_grid_min(self):
567        """command to read minimum grid supported by the module
568
569        :returns: The minimum grid supported by the module in GHz
570
571        """
572        try:
573            freq_lgrid = int.from_bytes(self._lgrid(), "big", signed=False)
574            freq_lgrid2 = int.from_bytes(self._lgrid2(), "big", signed=False)
575
576        except ExecutionError:
577            self.nop()
578
579        return freq_lgrid * 1e-1 + freq_lgrid2 * 1e-3
580
581    def set_grid(self, grid_freq):
582        """Set the grid spacing in GHz.
583
584        MHz resolution.
585
586        :param grid_freq: the grid frequency spacing in GHz
587        :returns:
588
589        """
590        grid_freq = str(round(grid_freq * 1000))
591        data = int(grid_freq[0:4])
592        data_2 = int(grid_freq[4:])
593
594        self._grid(data)
595        self._grid2(data_2)
596
597    def get_grid(self):
598        """get the grid spacing in GHz
599
600        :returns: The grid spacing in GHz.
601
602        """
603        response = self._grid()
604        grid_freq = int.from_bytes(response, "big", signed=True)
605
606        response = self._grid2()
607        grid2_freq = int.from_bytes(response, "big", signed=True)
608
609        return grid_freq * 1e-1 + grid2_freq * 1e-3
610
611    def get_age(self):
612        """Returns the percentage of aging of the laser.
613        0% indicated a brand new laser
614        100% indicates the laser should be replaces.
615
616        :returns:
617
618        """
619        response = self._age()
620        age = int.from_bytes(response, "big")
621
622        return age
623
624    def set_channel(self, channel):
625        """Sets the laser's operating channel.
626
627        MSA-01.3 lasers support a 32 bit channel value.
628
629        This defines how many spaces along the grid
630        the laser's frequency is displaced from the first channel frequency.
631
632        :param channel:
633        :returns:
634
635        """
636        # check type and stuff
637        if not isinstance(channel, int):
638            raise TypeError("Channel must be an integer")
639        if channel < 0:
640            raise ValueError("Channel must be positive.")
641        if channel > 0xFFFFFFFF:
642            raise ValueError("Channel must be a 32 bit integer (<=0xFFFFFFFF).")
643
644        # Split the channel choice into two options.
645        channel_hex = f"{channel:08x}"
646
647        channell = int(channel_hex[4:], 16)
648        channelh = int(channel_hex[0:4], 16)
649
650        # Set the channel registers.
651        self._channel(channell)
652        self._channelh(channelh)
653
654    def get_channel(self):
655        """gets the current channel setting
656
657        The channel defines how many spaces along the grid
658        the laser's frequency is displaced from the first channel frequency.
659
660        :returns: channel as an integer.
661
662        """
663        # This concatenates the data bytestrings
664        response = self._channelh() + self._channel()
665
666        channel = int.from_bytes(response, "big")
667
668        return channel
669
670    def set_fine_tuning(self, ftf):
671        """
672        This function provides off grid tuning for the laser's frequency.
673        The adjustment applies to all channels uniformly.
674        This is typically used after the laser if locked and minor adjustments
675        are required to the frequency.
676
677        The command may be pending in the event that the laser output is
678        enabled. The pending bit is cleared once the fine tune frequency
679        has been achieved.
680
681        **???** It seems like this can be done with the laser running.
682
683        :param ftf: The fine tune frequency adjustment in GHz
684        """
685
686        ftf = round(ftf * 1e3)
687
688        # We will leave this bare. This way the user can set and handle
689        # their own timing and check to make sure the laser has reached the
690        # desired fine tuning frequency.
691        # It WILL throw a "pending" error if the laser is on when setting.
692        self._ftf(ftf)
693
694    def get_fine_tuning(self):
695        """
696        This function returns the setting for the
697        off grid tuning for the laser's frequency.
698
699        :return ftf: The fine tune frequency adjustment in GHz
700        """
701
702        response = self._ftf()
703        ftf = int.from_bytes(response, "big", signed=True)
704
705        return ftf * 1e-3
706
707    def get_ftf_range(self):
708        """
709        Return the maximum and minimum off grid tuning for the laser's frequency.
710
711        :return ftfr: The fine tune frequency range [-ftfr, + ftfr] in GHz
712        """
713        response = self._ftfr()
714
715        ftfr = int.from_bytes(response, "big")
716
717        return ftfr * 1e-3
718
719    def get_temps(self):
720        """
721        Returns a list of currents in degrees Celcius.
722        In the following order:
723
724        Technology 1: [Diode Temp, Case Temp]
725        """
726        # get response this should be a long byte string
727        response = self._temps()
728
729        data = [
730            int.from_bytes(response[i : i + 2], "big", signed=True) / 100
731            for i in range(0, len(response), 2)
732        ]
733
734        return data
735
736    def get_currents(self):
737        """
738        Returns a list of currents in mA.
739        In the following order:
740
741        Technology 1: [TEC, Diode]
742        Technology 2: [TED, Diode 1, Diode 2, Diode 3, Diode 4, SOA]
743        Technology 3: [TEC, Diode 1, tbd, tbd, tbd, ...]
744        """
745        # get response this should be a long byte string
746        response = self._currents()
747
748        data = [
749            int.from_bytes(response[i : i + 2], "big", signed=True) / 10
750            for i in range(0, len(response), 2)
751        ]
752
753        return data
754
755    def get_last_response(self):
756        """This function gets the most recent response sent from the laser.
757        The response is parsed for errors and stuff the way any normal response
758        would be. The variable `self._response` is set to the last response again.
759
760        I dont know why you would need to do this.
761        """
762        return self._lstresp()
763
764    def get_error_fatal(self, reset=False):
765        """
766        reads fatal error register statusf and checks each bit against the
767        fatal error table to determine the fault
768
769        :param reset: resets/clears latching errors
770
771        """
772        response = self._statusf()
773        statusf = int.from_bytes(response, "big")
774
775        logger.debug("Current Status Fatal Error: %d", statusf)
776
777        if reset:
778            data_reset = 0x00FF
779            self._statusf(data_reset)
780
781        return FatalError(statusf)
782
783    def get_error_warning(self, reset=False):
784        """
785        reads warning error register statusw and checks each bit against the
786        warning error table to determine the fault
787
788        If the laser is off then some of the latched warnings will be set on.
789
790        :param reset: resets/clears latching errors
791        """
792        response = self._statusw()
793        statusw = int.from_bytes(response, "big")
794
795        logger.debug("Current Status Warning Error: %d", statusw)
796
797        if reset:
798            data_reset = 0x00FF
799            self._statusw(data_reset)
800
801        return WarningError(statusw)
802
803    def get_fatal_power_thresh(self):
804        """
805        reads maximum plus/minus power deviation in dB for which the fatal alarm is asserted
806
807        """
808        response = self._fpowth()
809        pow_fatal = int.from_bytes(response, "big") / 100
810        # correcting for proper order of magnitude
811        return pow_fatal
812
813    def get_warning_power_thresh(self):
814        """
815        reads maximum plus/minus power deviation in dB for which the warning alarm is asserted
816
817        """
818        response = self._wpowth()
819        pow_warn = int.from_bytes(response, "big") / 100
820        # correcting for proper order of magnitude
821        return pow_warn
822
823    def get_fatal_freq_thresh(self):
824        """
825        reads maximum plus/minus frequency deviation in GHz for which the fatal alarm is asserted
826
827        """
828        response = self._ffreqth()
829        freq_fatal = int.from_bytes(response, "big") / 10
830        # correcting for proper order of magnitude
831        response2 = self._ffreqth2()
832        freq_fatal2 = int.from_bytes(response2, "big") / 100
833        # get frequency deviation in MHz and add to GHz value
834        return freq_fatal + freq_fatal2
835
836    def get_warning_freq_thresh(self):
837        """
838        reads maximum plus/minus frequency deviation in GHz for which the warning alarm is asserted
839
840        """
841        response = self._wfreqth()
842        freq_warn = int.from_bytes(response, "big") / 10
843        # correcting for proper order of magnitude
844        response2 = self._wfreqth2()
845        freq_warn2 = int.from_bytes(response2, "big") / 100
846        # get frequency deviation in MHz and add to GHz value
847        return freq_warn + freq_warn2
848
849    def get_fatal_therm_thresh(self):
850        """
851        reads maximum plus/minus thermal deviation in degree celcius for which the fatal alarm is asserted
852
853        """
854        response = self._fthermth()
855        therm_fatal = int.from_bytes(response, "big") / 100
856        # correcting for proper order of magnitude
857        return therm_fatal
858
859    def get_warning_therm_thresh(self):
860        """
861        reads maximum plus/minus thermal deviation in degree celcius for which the warning alarm is asserted
862        """
863        response = self._wthermth()
864        therm_thresh = int.from_bytes(response, "big") / 100
865        # correcting for proper order of magnitude
866        return therm_thresh
867
868    def get_srq_trigger(self):
869        """
870        Utilizes SRQT register to identify why SRQ was asserted in StatusF and StatusW registers
871
872        """
873        response = self._srqt()
874        status = int.from_bytes(response, "big")
875
876        logger.debug("SRQT Status: %d", status)
877
878        return SQRTrigger(status)
879
880    def get_fatal_trigger(self):
881        """
882        Utilizes FatalT register to identify which fatal conditon was asserted in StatusF and StatusW registers
883
884        """
885        response = self._fatalt()
886        status = int.from_bytes(response, "big")
887
888        logger.debug("FatalT Status: %d", status)
889
890        return FatalTrigger(status)
891
892    def get_alm_trigger(self):
893        """
894        Utilizes ALMT register to identify why ALM was asserted in StatusF and StatusW registers
895
896        """
897        response = self._almt()
898        status = int.from_bytes(response, "big")
899
900        logger.debug("AlarmT Status: %d", status)
901
902        return AlarmTrigger(status)