[seq/zynq] Add helper for converting between floating point and machine unit

yuyichao · yuyichao · commit 245205f989bc · 2026-01-18T16:12:46.000-05:00
diff --git a/lib/nacs-seq/CMakeLists.txt b/lib/nacs-seq/CMakeLists.txt
@@ -11,7 +11,8 @@ set(nacs_seq_zynq_HDRS
   zynq/cmdlist.h
   zynq/pulse_time.h
   zynq/seq_shared.h
-  zynq/legacy_seq.h)
+  zynq/legacy_seq.h
+  zynq/utils.h)
 set(nacs_seq_nidaq_HDRS
   nidaq/backend.h
   nidaq/data_gen.h)
diff --git a/lib/nacs-seq/zynq/bc_gen.cpp b/lib/nacs-seq/zynq/bc_gen.cpp
@@ -19,6 +19,7 @@
 #include "bc_gen.h"
 
 #include "bytecode.h"
+#include "utils.h"
 #include "../../nacs-utils/processor.h"
 
 #include <string.h>
@@ -461,37 +462,14 @@ NACS_EXPORT() uint32_t BCGen::convert_value(ChnType type, double value)
     switch (type) {
     case ChnType::TTL:
         return value != 0;
-    case ChnType::Freq: {
-        constexpr double factor = 1.0 * (1 << 16) * (1 << 16) / 3.5e9;
-        if (value <= 0)
-            return 0;
-        // The instruction only have 31 bits so it actually won't encode exactly 1.75 GHz.
-        if (value > 1.7499999987776392e9) // last float that would round to 2^31 - 2
-            return 0x7fffffff;
-        return round<int32_t>(value * factor);
-    }
-    case ChnType::Amp: {
-        constexpr double factor = 4095;
-        if (value <= 0)
-            return 0;
-        if (value >= 1)
-            return 4095;
-        return round<int32_t>(value * factor);
-    }
-    case ChnType::Phase: {
-        // Value is phase in [0, 1]
-        return round<int32_t>(value * (1 << 16)) & ((1 << 16) - 1);
-    }
-    case ChnType::DAC: {
-        constexpr double factor = 65535 / 20.0;
-        constexpr double offset = 10.0;
-        if (value <= -10)
-            return 0;
-        if (value >= 10)
-            return 0xffff;
-        value += offset;
-        return round<int32_t>(value * factor);
-    }
+    case ChnType::Freq:
+        return dds_freq_to_mu(value);
+    case ChnType::Amp:
+        return dds_amp_to_mu(value);
+    case ChnType::Phase:
+        return dds_phase_to_mu(value);
+    case ChnType::DAC:
+        return dac_to_mu(value);
     default:
         return 0;
     }
diff --git a/lib/nacs-seq/zynq/exehelper_p.h b/lib/nacs-seq/zynq/exehelper_p.h
@@ -22,6 +22,7 @@
 #include <ostream>
 
 #include "pulse_time.h"
+#include "utils.h"
 
 // This file contains a few classes/functions that are useful for both bytecode
 // and command list.
@@ -61,8 +62,7 @@ struct Printer {
     {
         stm << "freq(" << int(chn) << ")=";
         if (dec) {
-            constexpr double factor = 3.5e9 / (1 << 16) / (1 << 16);
-            stm << double(freq) * factor << std::endl;
+            stm << dds_freq_from_mu(freq) << std::endl;
         }
         else {
             stm << "0x" << std::hex << freq << std::dec << std::endl;
@@ -72,7 +72,7 @@ struct Printer {
     {
         stm << "amp(" << int(chn) << ")=";
         if (dec) {
-            stm << amp / 4095.0 << std::endl;
+            stm << dds_amp_from_mu(amp) << std::endl;
         }
         else {
             stm << "0x" << std::hex << amp << std::dec << std::endl;
@@ -82,7 +82,7 @@ struct Printer {
     {
         stm << "phase(" << int(chn) << ")=";
         if (dec) {
-            stm << phase / double(1 << 16) << std::endl;
+            stm << dds_phase_from_mu(phase) << std::endl;
         }
         else {
             stm << "0x" << std::hex << phase << std::dec << std::endl;
diff --git a/lib/nacs-seq/zynq/legacy_seq.cpp b/lib/nacs-seq/zynq/legacy_seq.cpp
@@ -18,6 +18,7 @@
 
 #include "legacy_seq.h"
 #include "bytecode.h"
+#include "utils.h"
 
 #include "../../nacs-utils/number.h"
 #include "../../nacs-utils/streams.h"
@@ -501,12 +502,9 @@ class Writer {
         return PulseTime::Clock;
     }
 
-    static constexpr double freq_factor = 1.0 * (1 << 16) * (1 << 16) / 3.5e9;
     int addDDSFreq(uint64_t t, uint8_t chn, double freqf)
     {
-        uint32_t freq = uint32_t(0.5 + freqf * freq_factor);
-        if (freq > 0x7fffffff)
-            freq = 0x7fffffff;
+        uint32_t freq = dds_freq_to_mu(freqf);
         if (dds[chn].freq_set && freq == dds[chn].freq)
             return 0;
         addWait(t - cur_t);
@@ -536,9 +534,7 @@ class Writer {
 
     int addDDSAmp(uint64_t t, uint8_t chn, double ampf)
     {
-        uint16_t amp = uint16_t(ampf * 4095.0 + 0.5);
-        if (amp > 4095)
-            amp = 4095;
+        uint16_t amp = dds_amp_to_mu(ampf);
         if (dds[chn].amp_set && amp == dds[chn].amp)
             return 0;
         addWait(t - cur_t);
@@ -560,19 +556,7 @@ class Writer {
 
     int addDAC(uint64_t t, uint8_t chn, double Vf)
     {
-        uint16_t V;
-        if (Vf >= 10) {
-            V = 0;
-        }
-        else if (Vf <= -10) {
-            V = 0xffff;
-        }
-        else {
-            // this is for the DAC8814 chip in SPI0
-            double scale = 65535 / 20.0;
-            double offset = 10.0;
-            V = uint16_t(((offset - Vf) * scale) + 0.5);
-        }
+        uint16_t V = dac_to_mu(Vf);
         if (dac[chn].set && V == dac[chn].V)
             return 0;
         addWait(t - cur_t);
diff --git a/lib/nacs-seq/zynq/parser.cpp b/lib/nacs-seq/zynq/parser.cpp
@@ -18,6 +18,7 @@
 
 #include "parser_p.h"
 #include "pulse_time.h"
+#include "utils.h"
 
 #include "../../nacs-utils/errors.h"
 
@@ -347,8 +348,7 @@ std::pair<uint8_t,uint32_t> ParserBase::read_freqcmd()
         }
         if (freq_hz > 1.75e9)
             syntax_error("Frequency too high (max 1.75GHz)", -1, freq_hz_start + 1, colno);
-        constexpr double freq_factor = 1.0 * (1 << 16) * (1 << 16) / 3.5e9;
-        freq = uint32_t(0.5 + freq_hz * freq_factor);
+        freq = dds_freq_to_mu(freq_hz);
     }
     return {chn, freq};
 }
@@ -364,7 +364,7 @@ std::pair<uint8_t,uint16_t> ParserBase::read_ampcmd()
         auto [ampf, ampf_start] = read_float(0, 1);
         if (ampf_start == -1)
             syntax_error("Invalid amplitude", colno + 1);
-        amp = uint16_t(ampf * 4095.0 + 0.5);
+        amp = dds_amp_to_mu(ampf);
     }
     return {chn, amp};
 }
@@ -417,8 +417,7 @@ std::pair<uint8_t,std::pair<bool,uint16_t>> ParserBase::read_phasecmd()
         if (!(abs(phase_deg) <= 360 * 10))
             syntax_error("Phase too high (max +-1000%)", -1, phase_deg_start + 1, colno);
         phase_deg = fmod(phase_deg, 360);
-        constexpr double phase_factor = (1 << 14) / 90.0;
-        phase = uint16_t(0.5 + phase_deg * phase_factor);
+        phase = dds_phase_to_mu(phase_deg / 360.0);
     }
     if (neg)
         phase = uint16_t(-phase);
@@ -510,7 +509,7 @@ std::pair<bool,std::vector<uint32_t>> ParserBase::read_ttlmask(int max_bank)
             auto [ttl_mask, oldcol] = read_hex(0, UINT32_MAX);
             if (oldcol < 0)
                 syntax_error("Expecting hex literal", colno + 1);
-            ttl_masks.push_back(ttl_mask);
+            ttl_masks.push_back(uint32_t(ttl_mask));
             // Here we need to decide whether we expect a new mask value to be present.
             auto c0 = peek();
             if (!std::isspace(c0)) {
diff --git a/lib/nacs-seq/zynq/utils.h b/lib/nacs-seq/zynq/utils.h
@@ -0,0 +1,88 @@
+/*************************************************************************
+ *   Copyright (c) 2026 - 2026 Yichao Yu <yyc1992@gmail.com>             *
+ *                                                                       *
+ *   This library is free software; you can redistribute it and/or       *
+ *   modify it under the terms of the GNU Lesser General Public          *
+ *   License as published by the Free Software Foundation; either        *
+ *   version 3.0 of the License, or (at your option) any later version.  *
+ *                                                                       *
+ *   This library is distributed in the hope that it will be useful,     *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of      *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU    *
+ *   Lesser General Public License for more details.                     *
+ *                                                                       *
+ *   You should have received a copy of the GNU Lesser General Public    *
+ *   License along with this library. If not,                            *
+ *   see <http://www.gnu.org/licenses/>.                                 *
+ *************************************************************************/
+
+#ifndef __NACS_SEQ_ZYNQ_UTILS_H__
+#define __NACS_SEQ_ZYNQ_UTILS_H__
+
+#include "../../nacs-utils/number.h"
+
+namespace NaCs::Seq::Zynq {
+
+static inline uint32_t dds_freq_to_mu(double freq)
+{
+    constexpr double factor = 1.0 * (1 << 16) * (1 << 16) / 3.5e9;
+    if (freq <= 0)
+        return 0;
+    // The instruction only have 31 bits so it actually won't encode exactly 1.75 GHz.
+    if (freq > 1.7499999987776392e9) // last float that would round to 2^31 - 2
+        return 0x7fffffff;
+    return round<int32_t>(freq * factor);
+}
+
+static constexpr inline double dds_freq_from_mu(uint32_t freq)
+{
+    constexpr double factor = 3.5e9 / (1 << 16) / (1 << 16);
+    return double(freq) * factor;
+}
+
+static inline uint16_t dds_amp_to_mu(double amp)
+{
+    constexpr double factor = 4095;
+    if (amp <= 0)
+        return 0;
+    if (amp >= 1)
+        return 4095;
+    return (uint16_t)round<int32_t>(amp * factor);
+}
+
+static constexpr inline double dds_amp_from_mu(uint32_t amp)
+{
+    return double(amp) / 4095;
+}
+
+static inline uint32_t dds_phase_to_mu(double phase)
+{
+    // phase in [0, 1]
+    return round<int32_t>(phase * (1 << 16)) & ((1 << 16) - 1);
+}
+
+static constexpr inline double dds_phase_from_mu(uint32_t phase)
+{
+    return double(phase) / double(1 << 16);
+}
+
+static inline uint32_t dac_to_mu(double V)
+{
+    constexpr double factor = 65535 / 20.0;
+    constexpr double offset = 10.0;
+    if (V <= -10)
+        return 0;
+    if (V >= 10)
+        return 0xffff;
+    V += offset;
+    return round<int32_t>(V * factor);
+}
+
+static constexpr inline double dac_from_mu(uint32_t V)
+{
+    return V * (20.0 / 65535) - 10.0;
+}
+
+}
+
+#endif

Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,7 @@`
`22`	`22`	`#include <ostream>`
`23`	`23`
`24`	`24`	`#include "pulse_time.h"`
	`25`	`+#include "utils.h"`
`25`	`26`
`26`	`27`	`// This file contains a few classes/functions that are useful for both bytecode`
`27`	`28`	`// and command list.`
`@@ -61,8 +62,7 @@ struct Printer {`
`61`	`62`	`{`
`62`	`63`	`stm << "freq(" << int(chn) << ")=";`
`63`	`64`	`if (dec) {`
`64`		`- constexpr double factor = 3.5e9 / (1 << 16) / (1 << 16);`
`65`		`- stm << double(freq) * factor << std::endl;`
	`65`	`+ stm << dds_freq_from_mu(freq) << std::endl;`
`66`	`66`	`}`
`67`	`67`	`else {`
`68`	`68`	`stm << "0x" << std::hex << freq << std::dec << std::endl;`
`@@ -72,7 +72,7 @@ struct Printer {`
`72`	`72`	`{`
`73`	`73`	`stm << "amp(" << int(chn) << ")=";`
`74`	`74`	`if (dec) {`
`75`		`- stm << amp / 4095.0 << std::endl;`
	`75`	`+ stm << dds_amp_from_mu(amp) << std::endl;`
`76`	`76`	`}`
`77`	`77`	`else {`
`78`	`78`	`stm << "0x" << std::hex << amp << std::dec << std::endl;`
`@@ -82,7 +82,7 @@ struct Printer {`
`82`	`82`	`{`
`83`	`83`	`stm << "phase(" << int(chn) << ")=";`
`84`	`84`	`if (dec) {`
`85`		`- stm << phase / double(1 << 16) << std::endl;`
	`85`	`+ stm << dds_phase_from_mu(phase) << std::endl;`
`86`	`86`	`}`
`87`	`87`	`else {`
`88`	`88`	`stm << "0x" << std::hex << phase << std::dec << std::endl;`