atomiq.components.electronics.currentsource
===========================================

.. py:module:: atomiq.components.electronics.currentsource


Classes
-------

.. autoapisummary::

   atomiq.components.electronics.currentsource.CurrentSource
   atomiq.components.electronics.currentsource.HBridgedCurrentSource
   atomiq.components.electronics.currentsource.TTLHardwareLogicHBridgedCurrentSource
   atomiq.components.electronics.currentsource.TTLSoftwareLogicHBridgedCurrentSource
   atomiq.components.electronics.currentsource.RPCCurrentSource
   atomiq.components.electronics.currentsource.RPCCurrentSourceChannel
   atomiq.components.electronics.currentsource.VoltageControlledCurrentSource


Module Contents
---------------

.. py:class:: CurrentSource(min_current = float('-inf'), max_current = float('inf'), default_ramp_steps = 30, *args, **kwargs)

   Bases: :py:obj:`atomiq.components.primitives.Component`, :py:obj:`atomiq.components.primitives.Parametrizable`


   Current Source

   This abstract class represents any device that can output a defined, controllable current.

   :param min_current: The minimum current the device can output [A]
   :param max_current: The maximum current the device can output [A]
   :param default_ramp_steps: The default number of steps that this device should use if the current is ramped. This
                              value is only used if no ``ramp_steps`` are given in the :func:`ramp_current` method.


   .. py:attribute:: kernel_invariants


   .. py:attribute:: current


   .. py:attribute:: min_current


   .. py:attribute:: max_current


   .. py:attribute:: default_ramp_steps
      :value: 30



   .. py:method:: set_current(current)

      Set the current delivered by the current source

      :param current: Current in A



   .. py:method:: _set_current(current)
      :abstractmethod:



   .. py:method:: _ramp_current(duration, current_start, current_end, ramp_timestep = 0.0002)

      This method implements a stupid ramp on an abstract level. This will most likely work but be slow.
      If your hardware has native support for ramping, please override this function when you inherit from
      currentSource



   .. py:method:: ramp_current(duration, current_end, current_start = float('nan'), ramp_timestep = float('nan'), ramp_steps = -1)

      Ramp current over a given duration.

      This method advances the timeline by `duration`

      :param duration: ramp duration [s]
      :param current_end: end current [A]
      :param current_start: initial current [A]. If not given, the ramp starts from the current operating current.



.. py:class:: HBridgedCurrentSource(current_source, *args, **kwargs)

   Bases: :py:obj:`CurrentSource`, :py:obj:`atomiq.components.primitives.Switchable`


   Combination of an H-bridge and a current source

   Combining an H-bridge with a unipolar current source allows to create a bipolar current source. This class bundles
   these two comoponents an exposes them as a bipolar current source.

   :param current_source: The current source connected to the H-bridge


   .. py:class:: HBridgeState

      Bases: :py:obj:`enum.IntEnum`


      Enum where members are also (and must be) ints


      .. py:attribute:: FORWARD
         :value: (1,)



      .. py:attribute:: OFF
         :value: (0,)



      .. py:attribute:: REVERSE
         :value: -1




   .. py:attribute:: kernel_invariants


   .. py:attribute:: current_source


   .. py:attribute:: state


   .. py:attribute:: last_state


   .. py:method:: hbridge_off()


   .. py:method:: hbridge_reverse()


   .. py:method:: hbridge_forward()


   .. py:method:: hbridge_toggle()


   .. py:method:: _hbridge_off()
      :abstractmethod:



   .. py:method:: _hbridge_forward()
      :abstractmethod:



   .. py:method:: _hbridge_reverse()
      :abstractmethod:



   .. py:method:: _set_current(current)


   .. py:method:: _ramp_current(duration, current_start, current_end, ramp_timestep)

      This method implements a stupid ramp on an abstract level. This will most likely work but be slow.
      If your hardware has native support for ramping, please override this function when you inherit from
      currentSource



   .. py:method:: off()


   .. py:method:: on()


.. py:class:: TTLHardwareLogicHBridgedCurrentSource(switch_direction, switch_on, invert_direction = False, *args, **kwargs)

   Bases: :py:obj:`HBridgedCurrentSource`


   H-bridged current source with control logic implemented in hardware

   Some external hardware (logic gates) take care to set all MOSFETs of the H-bridge based on the desired direction
   as indicated by `switch_direction`. Via `switch_on` the entire bridge can be enabled and disabled.

   +---------------+----------------------+---------------------+
   | ``switch_on`` | ``switch_direction`` | current flow        |
   +===============+======================+=====================+
   | off           | on                   | off                 |
   +---------------+----------------------+---------------------+
   | off           | off                  | off                 |
   +---------------+----------------------+---------------------+
   | on            | on                   | forward             |
   +---------------+----------------------+---------------------+
   | on            | off                  | reverse             |
   +---------------+----------------------+---------------------+

   :param switch_on: When ON, H-bridge is eith forward or reverse; when OFF, load is disconnected from the PSU
   :param switch_direction: select forward or reverse direction of current flow
   :param invert_direction: flip forward/reverse


   .. py:attribute:: kernel_invariants


   .. py:attribute:: switch_direction


   .. py:attribute:: switch_on


   .. py:attribute:: invert_direction
      :value: False



   .. py:method:: _hbridge_off()


   .. py:method:: _hbridge_forward()


   .. py:method:: _hbridge_reverse()


.. py:class:: TTLSoftwareLogicHBridgedCurrentSource(switch_forward, switch_reverse, *args, **kwargs)

   Bases: :py:obj:`HBridgedCurrentSource`


   H-bridged current source with control logic implemented in software

   Each pair of MOSFETs is directly controlled by one switch. So when both TTLs are off, the bridge is off, but also
   when both are on the PSU is shorted.

   +--------------------+--------------------+--------------------+
   | ``switch_forward`` | ``switch_reverse`` | current flow       |
   +====================+====================+====================+
   | off                | off                | off                |
   +--------------------+--------------------+--------------------+
   | off                | on                 | reverse            |
   +--------------------+--------------------+--------------------+
   | on                 | off                | forward            |
   +--------------------+--------------------+--------------------+
   | on                 | on                 | INVALID            |
   +--------------------+--------------------+--------------------+

   :param switch_forward: TTL to enable forward pair of MOSFETs
   :param switch_reverse: TTL to enable reverse pair of MOSFETs


   .. py:attribute:: kernel_invariants


   .. py:attribute:: switch_forward


   .. py:attribute:: switch_reverse


   .. py:method:: _hbridge_off()


   .. py:method:: _hbridge_forward()


   .. py:method:: _hbridge_reverse()


.. py:class:: RPCCurrentSource(rpc_currentsource, *args, **kwargs)

   Bases: :py:obj:`CurrentSource`


   A current source controlled via RPC calls

   :param rpc_currentsource: The ARTIQ rpc object representing the current source. This object needs to provide a
                             function named `set_current(current_in_A)` to set the current.


   .. py:attribute:: kernel_invariants


   .. py:attribute:: currentsource


   .. py:method:: _set_current(current)


.. py:class:: RPCCurrentSourceChannel(rpc_currentsource, channel, *args, **kwargs)

   Bases: :py:obj:`CurrentSource`


   One channel of a multi-channel currentsource controlled via RPC

   :param rpc_currentsource: The ARTIQ rpc object representing the multi channel current source. This object needs to
                             provide a function named `set_current(current_in_A, channel)` to set the current.
   :param channel: channel of the multi-channel current source to operate on


   .. py:attribute:: kernel_invariants


   .. py:attribute:: currentsource


   .. py:attribute:: channel


   .. py:method:: _set_current(current)


.. py:class:: VoltageControlledCurrentSource(voltage_source, calibration, *args, **kwargs)

   Bases: :py:obj:`CurrentSource`


   A current source controlled by an analog voltage

   A typical usecase for this class are voltage-controlled power supplies that drive the current through a coil.

   :param voltage_source: Voltage source that controls the current source
   :param calibration: Calibration U = f(I) to give the control voltage U for a desired current I


   .. py:attribute:: kernel_invariants


   .. py:attribute:: voltage_source


   .. py:attribute:: calibration


   .. py:method:: _set_current(current)


   .. py:method:: _ramp_current(duration, current_start, current_end, ramp_timestep)

      This method implements a stupid ramp on an abstract level. This will most likely work but be slow.
      If your hardware has native support for ramping, please override this function when you inherit from
      currentSource