-
Notifications
You must be signed in to change notification settings - Fork 1
/
README.txt
151 lines (114 loc) · 5.52 KB
/
README.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
Tweak of the following library for use with STM32 and other non_AVR platforms.
T. Combriat
Arduino library for the Microchip MCP49x1/MCP49x2 series DACs
Thomas Backman <serenity@exscape.org>, 2012
Version 1.1 (October 2, 2012)
Changes from v1.0:
* Support for MCP49x2 series DACs added; thanks to Jonas Gruska for idea/code/testing
* Library renamed from DAC_MCP49x1 to DAC_MCP49xx
Supported models:
* MCP4901 (8-bit, single)
* MCP4911 (10-bit, single)
* MCP4921 (12-bit, single)
* MCP4902 (8-bit, dual)
* MCP4912 (10-bit, dual)
* MCP4922 (12-bit, dual)
Example usage:
/////////////////////////////////
#include <SPI.h> // Remember this line!
#include <DAC_MCP49xx.h>
DAC_MCP49xx dac(DAC_MCP49xx::MCP4901, 10); // DAC model, SS pin
void setup() {
dac.init();
}
void loop() {
dac.output(255);
delay(2500);
dac.output(0);
delay(2500);
}
/////////////////////////////////
See the example sketches for slightly more detailed examples.
** LATCH has been removed for compatibility: just tie LDAC to GND **
A note on latching/LDAC:
The way these DACs work is as follows: when a value is sent to them via
the output*() methods, the output does not instantly change.
Instead, the DAC waits until the LDAC pin has been pulled low. Therefore,
if that pin is tied to ground, the output *will* instantly change.
However, if that pin is connected to the Arduino, you will need to latch
the output in order for a change to happen. There are two ways to do this:
1) Call latch(), which creates a low pulse
2) MCP49x2 only: call output2(), with the automaticallyLatchDual option set
(true by default), which will then call latch() for you
The main usage of this functionality is to synchronize multiple DACs (2 or more),
to make their outputs change at the same moment, despite having the data sent
to them one at a time.
Simple function overview:
Constructor (DAC_MCP49xx, int SS_pin)
Takes three arguments: the DAC model (MCP4901, MCP4911, MCP4921,
MCP4902, MCP4912 or MCP4922), the chip select pin, and the LDAC pin.
If the LDAC functionality isn't wanted (if you don't know, you likely don't
want it), make sure the LDAC pin is tied to ground, and simply ignore that
argument (or pass -1).
setBuffer(bool)
Should the DAC buffer the reference voltage?
Note: if "true", VREF cannot be VDD (e.g. +5 V). Defaults to false.
setGain(int)
Sets the gain. The output voltage is x/2^n * VREF * gain, where x = the value
passed to out and n = the number of bits
For example, for a 8-bit DAC with gain 2x and VREF = 5 V where out(100) is
called, vout = 100/256 * 5 * 2 = 3.90625 V.
Only 1 and 2 are valid values!
Defaults to 1x.
setSPIDivider(int) ** REMOVED
Sets the SPI clock frequency. See the Arduino docs: http://arduino.cc/en/Reference/SPISetClockDivider
Uses the same constants (SPI_CLOCK_DIV2 etc.) as in the Arduino docs.
setAutomaticallyLatchDual(bool) ** REMOVED
If true: will automatically pull the LDAC pin low after output2() is called.
If false: won't do the above.
Only relevant for the MCP49x2 dual DACs.
Defaults to true.
shutdown(void)
Shuts the DAC down to save power. (~3.5 µA in standby, ~150 µA powered up.)
Settling time after calling set() increases from ~5 to ~10 µs when in standby.
output(unsigned short)
MCP49x1 (single DAC) only.
Sends the value to the DAC. If the LDAC pin is tied to ground, Vout will change "instantly".
If the LDAC pin is connected to the Arduino, nothing will change until latch() is called.
outputA(unsigned short)
MCP49x2 (dual DAC) only.
Sends the value to DAC A. Same as output().
outputB(unsigned short)
MCP49x2 (dual DAC) only.
Sends the value to DAC B. Otherwise same as output().
output2(unsigned short, unsigned short)
MCP49x2 (dual DAC) only.
Sends the two output values to the two outputs of the dual DACs.
Latches the output automatically unless setAutomaticallyLatchDual() has been
called with 'false' as the argument.
latch(void) ** REMOVED
Changes the output voltage based on the last value(s) sent using the output*() methods.
Creates a low pulse on the DAC's LDAC pin (pin 5 on the DAC chip).
The LDAC pin can be tied to ground instead, to update automatically ASAP, in
which case this method does nothing.
init()
Need to be called in setup(), for good SPI compatibility.
init(& SPIClass)
If you want to use another SPI port.
setPortWrite(bool)
Note: PortWrite is not supported on the Arduino Leonardo, but should work on
the Uno and Mega. (One could change this by changing the ports used in the code.)
*** The CS and LDAC pins set in the constructor are IGNORED when this is set to true!!! ***
PortWrite is a method that speeds up the code significantly, but only works on fixed pins (see below).
It's roughly 30 times faster than digitalWrite in my measurements for this code.
(That doesn't mean that the entire code is 30 times faster, but changing a pin value is.)
In order to use the faster method e.g. on the Arduino Uno, you must use pin 7 on the Uno for the LDAC pin,
and pin 10 for the CS pin. Anything else won't work. If these pins are busy doing something else, you can't use this speed-up
without modifying the code.
Use these pins:
For the CS pin: PD7 (Uno: digital pin 7, Mega: digital pin 38)
Also note that since these are fixed, and CS cannot be shared between devices, *you can't use multiple DACs with PortWrite enabled*!
So, in short...
Pro: much faster (only matters for relatively high-frequency stuff;
the difference is on the order of a few microseconds)
Cons: only works on fixed pins, only works with 1 DAC, doesn't work on all Arduinos