docs/library/pyb.DAC.rst · QuecPython/microPython

【升级通知】Gitee 将于 7 月 11 日晚 23 点进行全站升级维护

代码拉取完成,页面将自动刷新

richgiteeai

Watch

不关注关注所有动态仅关注版本发行动态关注但不提醒动态

6 Star 12 Fork 11

QuecPython/microPython

代码 Issues 0 Pull Requests 0 Wiki 统计流水线

服务

加入 Gitee

与超过 1400万开发者一起发现、参与优秀开源项目,私有仓库也完全免费 :)

免费加入

已有帐号? 立即登录

文件

master

分支 (2)

管理

master

review

克隆/下载

HTTPS SSH SVN SVN+SSH 下载ZIP

提示

下载代码请复制以下命令到终端执行

为确保你提交的代码身份被 Gitee 正确识别,请执行以下命令完成配置

git config --global user.name userName 
git config --global user.email userEmail

初次使用 SSH 协议进行代码克隆、推送等操作时,需按下述提示完成 SSH 配置

1 生成 RSA 密钥

2 获取 RSA 公钥内容,并配置到 SSH公钥中

在 Gitee 上使用 SVN,请访问使用指南

使用 HTTPS 协议时,命令行会出现如下账号密码验证步骤。基于安全考虑,Gitee 建议配置并使用私人令牌替代登录密码进行克隆、推送等操作

Username for 'https://gitee.com': userName

Password for 'https://userName@gitee.com': # 私人令牌

分支 2

标签 0

microPython

docs

library

pyb.DAC.rst

pyb.DAC.rst 4.23 KB

.. currentmodule:: pyb
.. _pyb.DAC:

class DAC -- digital to analog conversion
=========================================

The DAC is used to output analog values (a specific voltage) on pin X5 or pin X6.
The voltage will be between 0 and 3.3V.

*This module will undergo changes to the API.*

Example usage::

from pyb import DAC

dac = DAC(1) # create DAC 1 on pin X5
 dac.write(128) # write a value to the DAC (makes X5 1.65V)

dac = DAC(1, bits=12) # use 12 bit resolution
 dac.write(4095) # output maximum value, 3.3V

To output a continuous sine-wave::

import math
 from pyb import DAC

# create a buffer containing a sine-wave
 buf = bytearray(100)
 for i in range(len(buf)):
 buf[i] = 128 + int(127 * math.sin(2 * math.pi * i / len(buf)))

# output the sine-wave at 400Hz
 dac = DAC(1)
 dac.write_timed(buf, 400 * len(buf), mode=DAC.CIRCULAR)

To output a continuous sine-wave at 12-bit resolution::

import math
 from array import array
 from pyb import DAC

# create a buffer containing a sine-wave, using half-word samples
 buf = array('H', 2048 + int(2047 * math.sin(2 * math.pi * i / 128)) for i in range(128))

# output the sine-wave at 400Hz
 dac = DAC(1, bits=12)
 dac.write_timed(buf, 400 * len(buf), mode=DAC.CIRCULAR)

Constructors
------------

.. class:: pyb.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.

Methods
-------

.. method:: DAC.init(bits=8, *, buffering=None)

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.

.. method:: DAC.deinit()

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

.. method:: DAC.noise(freq)

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

.. method:: DAC.triangle(freq)

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.

.. method:: DAC.write(value)

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.

.. method:: DAC.write_timed(data, freq, *, mode=DAC.NORMAL)

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)

一键复制编辑原始数据按行查看历史

chenchi 提交于 2021年06月03日 16:44 +08:00 . first commit

.. currentmodule:: pyb

class DAC -- digital to analog conversion

The DAC is used to output analog values (a specific voltage) on pin X5 or pin X6. The voltage will be between 0 and 3.3V.

This module will undergo changes to the API.

Example usage:

from pyb import DAC

dac = DAC(1) # create DAC 1 on pin X5
dac.write(128) # write a value to the DAC (makes X5 1.65V)

dac = DAC(1, bits=12) # use 12 bit resolution
dac.write(4095) # output maximum value, 3.3V

To output a continuous sine-wave:

import math
from pyb import DAC

# create a buffer containing a sine-wave
buf = bytearray(100)
for i in range(len(buf)):
 buf[i] = 128 + int(127 * math.sin(2 * math.pi * i / len(buf)))

# output the sine-wave at 400Hz
dac = DAC(1)
dac.write_timed(buf, 400 * len(buf), mode=DAC.CIRCULAR)

To output a continuous sine-wave at 12-bit resolution:

import math
from array import array
from pyb import DAC

# create a buffer containing a sine-wave, using half-word samples
buf = array('H', 2048 + int(2047 * math.sin(2 * math.pi * i / 128)) for i in range(128))

# output the sine-wave at 400Hz
dac = DAC(1, bits=12)
dac.write_timed(buf, 400 * len(buf), mode=DAC.CIRCULAR)

Constructors

Methods

.. method:: DAC.init(bits=8, *, buffering=None)

 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.

.. method:: DAC.deinit()

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

.. method:: DAC.noise(freq)

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

.. method:: DAC.triangle(freq)

 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.

.. method:: DAC.write(value)

 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.

.. method:: DAC.write_timed(data, freq, *, mode=DAC.NORMAL)

 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)