0.1.1 AD7390

Author: RobTillaart

libraries/AD7390/AD7390.cpp

@@ -1,7 +1,7 @@
 //
 //    FILE: AD7390.cpp
 //  AUTHOR: Rob Tillaart
-// VERSION: 0.1.0
+// VERSION: 0.1.1
 //    DATE: 2025-06-14
 // PURPOSE: Arduino library for AD7390/AD7391 12/10 bit SPI DAC.
 //     URL: https://github.com/RobTillaart/AD7390
@@ -12,25 +12,27 @@
 //  SOFTWARE SPI
 AD7390::AD7390(uint8_t select, uint8_t clear, uint8_t dataOut, uint8_t clock)
 {
-  _select   = select;
-  _clear    = clear;
-  _dataOut  = dataOut;
-  _clock    = clock;
-  _hwSPI    = false;
-  _mySPI    = NULL;
-  _maxValue = 4095;
+  _select     = select;
+  _clear      = clear;
+  _dataOut    = dataOut;
+  _clock      = clock;
+  _hwSPI      = false;
+  _mySPI      = NULL;
+  _maxValue   = 4095;
+  _refVoltage = 0;
 }
 
 //  HARDWARE SPI
 AD7390::AD7390(uint8_t select, uint8_t clear, __SPI_CLASS__ * mySPI)
 {
-  _select   = select;
-  _clear    = clear;
-  _dataOut  = 255;
-  _clock    = 255;
-  _hwSPI    = true;
-  _mySPI    = mySPI;
-  _maxValue = 4095;
+  _select     = select;
+  _clear      = clear;
+  _dataOut    = 255;
+  _clock      = 255;
+  _hwSPI      = true;
+  _mySPI      = mySPI;
+  _maxValue   = 4095;
+  _refVoltage = 0;
 }
 
 //  initializes the pins and starts SPI in case of hardware SPI
@@ -67,7 +69,7 @@ void AD7390::begin(uint16_t value)
 //
 bool AD7390::setValue(uint16_t value)
 {
-  if (_value > _maxValue) return false;
+  if (value > _maxValue) return false;
   _value = value;
   updateDevice(value);
   return true;
@@ -104,6 +106,31 @@ void AD7390::clear()
   _value = 0;
 }
 
+bool AD7390::setRefVoltage(float volts)
+{
+  if ((volts < 0) || (volts > 5.5)) return false;
+  _refVoltage = volts;
+  return true;
+}
+
+float AD7390::getRefVoltage()
+{
+  return _refVoltage;
+}
+
+bool AD7390::setVoltage(float volts)
+{
+  if ((volts < 0) || (volts > _refVoltage)) return false;
+  return setValue(round(volts * (_maxValue / _refVoltage)));
+}
+
+float AD7390::getVoltage()
+{
+  uint16_t v = _value;
+  if (v == 0) return 0.0;
+  return (_refVoltage / _maxValue) * v;
+}
+
 
 /////////////////////////////////////////////////////////////////////////////
 //
@@ -133,13 +160,13 @@ bool AD7390::usesHWSPI()
 void AD7390::updateDevice(uint16_t value)
 {
   digitalWrite(_select, HIGH);
-  if (_hwSPI)
+  if (_hwSPI)  //  hardware SPI
   {
     _mySPI->beginTransaction(_spi_settings);
     _mySPI->transfer16(value);
     _mySPI->endTransaction();
   }
-  else      //  Software SPI
+  else         //  software SPI
   {
     swSPI_transfer(value);
   }
@@ -150,7 +177,7 @@ void AD7390::swSPI_transfer(uint16_t value)
 {
   uint8_t clk = _clock;
   uint8_t dao = _dataOut;
-  for (uint16_t mask = 0x8000; mask; mask >>= 1)  //  0x0800 performance?
+  for (uint16_t mask = 0x8000; mask; mask >>= 1)
   {
     digitalWrite(dao,(value & mask));
     digitalWrite(clk, HIGH);

libraries/AD7390/AD7390.h

@@ -2,7 +2,7 @@
 //
 //    FILE: AD7390.h
 //  AUTHOR: Rob Tillaart
-// VERSION: 0.1.0
+// VERSION: 0.1.1
 //    DATE: 2025-06-14
 // PURPOSE: Arduino library for AD7390/AD7391 12/10 bit SPI DAC.
 //     URL: https://github.com/RobTillaart/AD7390
@@ -11,7 +11,7 @@
 #include "SPI.h"
 
 
-#define AD7390_LIB_VERSION              (F("0.1.0"))
+#define AD7390_LIB_VERSION              (F("0.1.1"))
 
 
 #ifndef __SPI_CLASS__
@@ -41,15 +41,17 @@ class AD7390
   bool     setValue(uint16_t value);
   uint16_t getValue();
   uint16_t getMaxValue();
+
   bool     setPercentage(float percentage);
   float    getPercentage();
 
   void     clear();  //  set DAC to zero.
 
-  //  REFVOLTAGE possible interface addition
-  //  bool setRefVoltage(float volts);
-  //  bool setVoltage(float volts);
-  //  float getVoltage();
+  //       ref voltage API
+  bool     setRefVoltage(float volts);
+  float    getRefVoltage();
+  bool     setVoltage(float volts);
+  float    getVoltage();
 
   //       speed in Hz
   void     setSPIspeed(uint32_t speed);
@@ -70,6 +72,7 @@ class AD7390
 
   uint16_t _value;
   uint16_t _maxValue;
+  float    _refVoltage;
 
   void     updateDevice(uint16_t value);
   void     swSPI_transfer(uint16_t value);

libraries/AD7390/CHANGELOG.md

@@ -6,6 +6,14 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
 
+## [0.1.1] - 2025-06-16
+- add four voltage functions.
+- fix setValue()
+- add examples
+- update keywords.txt
+- update readme.md
+- minor edits
+
 ## [0.1.0] - 2025-06-14
 - initial version
 

libraries/AD7390/README.md

@@ -28,14 +28,23 @@ The library is experimental as not all functionality is tested with hardware.
 
 Check datasheet for all details.
 
-The AD7390 has a Vref input which can be set to any voltage between 0 and Vdd (2.7 .. 5.5 Volt.
-This allows the output to vary between 0 volt and approx. Vref -1 LSB. 
+The AD7390 has a Vref input which can be set to any voltage between 0 and Vdd = 2.7 .. 5.5 Volt.
+This allows the output to vary between 0 volt and approx. Vref -1 LSB.
+The AD7390 can do this in 4096 levels, the AD7391 has 1024 levels.
+
 See datasheet page 8.
 
-The device does not support reading the set value, so the library caches the 
-last value set to provide this.
-Furthermore the library provides a "percentage" functions to set and get the output
-in a range from 0 to 100.0 %.
+The device does not support reading back the set value, so the library caches the 
+last value set to mimic this functionality.
+
+Furthermore the library provides "percentage" wrapper functions to set and get the 
+output in a range from 0 to 100.0 %. Note that setPercentage() will round to the 
+nearest valid integer value.
+
+Finally the library provides "voltage" wrapper functions to set and get the 
+output in a range from 0 to Vref. Note that setVoltage() will round to the nearest
+valid integer value. Be aware that the actual Vref must be set by setRefVoltage()
+and kept in sync with the actual voltage to have the voltage functions work correctly.
 
 As always feedback is welcome.
 
@@ -72,7 +81,26 @@ Mainly other DAC libraries.
 
 ## Performance
 
-TODO
+Times in microseconds per 1000 calls.
+
+|  mode  |  function       |  UNO R3  |  ESP32  |  notes  |
+|:------:|:----------------|:--------:|:-------:|:--------|
+| HW-SPI |  setValue       |  15404   |         |
+| HW-SPI |  getValue       |    884   |         |  cached value
+| HW-SPI |  setPercentage  |  93764   |         |
+|        |                 |          |         |
+| SW-SPI |  setValue       | 204332   |         |
+| SW-SPI |  getValue       |    884   |         |  cached value
+| SW-SPI |  setPercentage  | 282692   |         |
+
+
+Note: 15404 micros for 1000 calls, means the max update speed 
+is in the order of 60k calls per second in theory. 
+In practice one needs to calculate values or read them from some source,
+or do other tasks. So actual speeds depends on your project.
+
+The setPercentage and setVoltage functions have additional overhead 
+due to the use of float math.
 
 
 ## Interface
@@ -108,12 +136,31 @@ Returns false if value > maxValue.
 
 ### Percentage
 
+Wrapper functions.
+
 - **bool setPercentage(float percentage)** sets the value of the DAC as percentage 0..100.
 Note the actual value set gets rounded.
 Returns false if percentage < 0 or > 100. 
 - **float getPercentage()** returns the percentage set, calculated from the value.
 The percentage can differ a small bit from the percentage set. 
 
+### Voltage
+
+Wrapper functions.
+
+Before calling **setVoltage()** one must set the reference voltage correctly,
+otherwise the functions do not work. 
+The user is responsible to keep **setRefVoltage()** in sync with the actual Vref.
+
+- **bool setRefVoltage(float volts)** set Reference Voltage of Vref pin.
+Returns false if volts is out of range 0..5.5 Volt.
+- **float getRefVoltage()** return last set Reference Voltage, default 0.
+- **bool setVoltage(float volts)** sets the value of the DAC as a voltage 0..Vref.
+Note the actual value set gets rounded.
+Returns false if volts is out of range 0..Vref.
+- **float getVoltage()** returns the voltage set, calculated from the value.
+The voltage can differ a small bit from the voltage set. 
+
 ### Hardware SPI
 
 To be used only if one needs a specific speed for hardware SPI.  
@@ -137,16 +184,24 @@ Has no effect on software SPI.
 
 #### Should
 
-- add reference voltage functions. (See .h)
 - extend unit tests
-- add examples
 
 #### Could
 
+- **getLastUpdate()** track millis
+- if new value == cached value skip
+- optimize AVR SW SPI
+- optimize float math setPercentage() and setVoltage()
+  - calculate and cache the conversion Pfactor and Vfactor. (8 bytes)
+  - remove range test as setValue() does this?
+- test SW-SPI with 0x0800 mask (clock only 12 bits does that work).
+- add examples
 
 #### Wont
 
-
+- build in low pass filter (too complex)
+- should percentage and voltage API clip or fail if out of range?
+  - fail seems safest.
 
 ## Support
 

libraries/AD7390/examples/AD7390_demo/AD7390_demo.ino

@@ -7,8 +7,7 @@
 
 #include "AD7390.h"
 
-uint32_t start, stop;
-
+uint32_t start;
 
 //  select, reset, data, clock == SOFTWARE SPI
 //  AD7390 myDAC(6, 7, 11, 13);
@@ -30,10 +29,9 @@ void setup()
   SPI.begin();
   myDAC.begin(0);
 
-  //  test_extremes();
-  //  test_sinus();
-  //  test_sawtooth();
-  test_timing();
+  test_extremes();
+  test_sinus();
+  test_sawtooth();
 
   Serial.println("\nDone...");
 }
@@ -50,15 +48,12 @@ void test_extremes()
 
   Serial.println("0");
   myDAC.setValue(0);
-  delay(2000);
 
   Serial.println("2047");
   myDAC.setValue(2047);
-  delay(2000);
 
   Serial.println("4095");
   myDAC.setValue(4095);
-  delay(2000);
 }
 
 
@@ -72,8 +67,9 @@ void test_sinus()
   uint32_t i = 0;
   while (millis() - start < 10000)
   {
-    int8_t value = 2047 * sin(i * TWO_PI / 100);
+    int16_t value = 2047 * sin(i * TWO_PI / 100);
     myDAC.setValue(2047 + value);
+    Serial.println(2047 + value);
     i++;
   }
 }
@@ -86,40 +82,13 @@ void test_sawtooth()
 
   start = millis();
   uint16_t i = 0;
-  while (millis() - start < 25500)
+  while (millis() - start < 10000)
   {
     if (i >= 4095) i = 0;
-    myDAC.setValue(i++);  //  auto wrap is fast...
-    delay(100);
-  }
-}
-
-
-void test_timing()
-{
-  Serial.println(__FUNCTION__);
-  delay(10);
-
-  start = micros();
-  for (int i = 0; i < 1000; i++)
-  {
-    myDAC.setValue(i++);  //  auto wrap is fast...
-  }
-  stop = micros();
-  Serial.print("1000 x setValue():\t");
-  Serial.println(stop - start);
-  delay(10);
-
-  volatile int x = 0;
-  start = micros();
-  for (int i = 0; i < 1000; i++)
-  {
-    x += myDAC.getValue();
+    myDAC.setValue(i++);
+    Serial.println(i);
+    delay(1);
   }
-  stop = micros();
-  Serial.print("1000 x getValue():\t");
-  Serial.println(stop - start);
-  delay(10);
 }