pyb.DAC
=======
.. This document was autogenerated by Sphinx-autoapi from a .pyi stub or a source code file.
.. Do not edit this file, instead edit the source file and run Sphinx to update. 
.. Source: docs/stubs/pyb/DAC.pyi

.. py:module:: pyb.DAC


Classes
-------

.. autoapisummary::

   pyb.DAC.DAC


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

.. py:class:: DAC(port, bits=8, *, buffering=None)

   Construct a new DAC object.

   ``port`` can be a pin object, or an integer (1 or 2).
   DAC(1) is on pin X5 and DAC(2) is on pin X6.

   ``bits`` is an integer specifying the resolution, and can be 8 or 12.
   The maximum value for the write and write_timed methods will be
   2\*\*``bits``-1.

   The *buffering* parameter selects the behaviour of the DAC op-amp output
   buffer, whose purpose is to reduce the output impedance.  It can be
   ``None`` to select the default (buffering enabled for :meth:`DAC.noise`,
   :meth:`DAC.triangle` and :meth:`DAC.write_timed`, and disabled for
   :meth:`DAC.write`), ``False`` to disable buffering completely, or ``True``
   to enable output buffering.

   When buffering is enabled the DAC pin can drive loads down to 5KΩ.
   Otherwise it has an output impedance of 15KΩ maximum: consequently
   to achieve a 1% accuracy without buffering requires the applied load
   to be less than 1.5MΩ.  Using the buffer incurs a penalty in accuracy,
   especially near the extremes of range.


   .. py:method:: deinit() -> _typeshed.Incomplete

      De-initialise the DAC making its pin available for other uses.



   .. py:method:: init(bits=8, *, buffering=None) -> _typeshed.Incomplete

      Reinitialise the DAC.  *bits* can be 8 or 12.  *buffering* can be
      ``None``, ``False`` or ``True``; see above constructor for the meaning
      of this parameter.



   .. py:method:: noise(freq) -> None

      Generate a pseudo-random noise signal.  A new random sample is written
      to the DAC output at the given frequency.



   .. py:method:: triangle(freq) -> None

      Generate a triangle wave.  The value on the DAC output changes at the given
      frequency and ramps through the full 12-bit range (up and down). Therefore
      the frequency of the repeating triangle wave itself is 8192 times smaller.



   .. py:method:: write(value) -> _typeshed.Incomplete

      Direct access to the DAC output.  The minimum value is 0.  The maximum
      value is 2\*\*``bits``-1, where ``bits`` is set when creating the DAC
      object or by using the ``init`` method.



   .. py:method:: write_timed(data, freq, *, mode=NORMAL) -> _typeshed.Incomplete

      Initiates a burst of RAM to DAC using a DMA transfer.
      The input data is treated as an array of bytes in 8-bit mode, and
      an array of unsigned half-words (array typecode 'H') in 12-bit mode.

      ``freq`` can be an integer specifying the frequency to write the DAC
      samples at, using Timer(6).  Or it can be an already-initialised
      Timer object which is used to trigger the DAC sample.  Valid timers
      are 2, 4, 5, 6, 7 and 8.

      ``mode`` can be ``DAC.NORMAL`` or ``DAC.CIRCULAR``.

      Example using both DACs at the same time::

        dac1 = DAC(1)
        dac2 = DAC(2)
        dac1.write_timed(buf1, pyb.Timer(6, freq=100), mode=DAC.CIRCULAR)
        dac2.write_timed(buf2, pyb.Timer(7, freq=200), mode=DAC.CIRCULAR)



   .. py:attribute:: CIRCULAR
      :type:  _typeshed.Incomplete

      CIRCULAR mode does a transmission of the waveform in the data buffer, and wraps around
      to the start of the data buffer every time it reaches the end of the table.


   .. py:attribute:: NORMAL
      :type:  _typeshed.Incomplete

      NORMAL mode does a single transmission of the waveform in the data buffer,