Merge pull request #96 from tknopp/dac-rework

16-bit DAC rework and FIR bypass

Author: jusack

CHANGELOG.md

@@ -0,0 +1,31 @@
+# Changelog
+
+## 0.11.0
+
+### Breaking Changes
+- **Breaking**: Updated ADC and DAC pipeline requires a new ADC and DAC calibration after the update!
+- **Breaking**: When not using the ADC calibration the integer values will now be in the range of [-32768, 32767] instead of [-8192, 8191]
+
+### Updated ADC Pipeline
+- The decimating pipeline after the ADC now uses the full 16-bit accuracy decreasing the quantization noise which becomes dominant over the ADC noise at high decimations (>256)
+- The FIR filter added in v0.6.0 can now be switched on and off using `firEnabled!`. For all standard applications the filter should be left on for improved anti-aliasing and flatter frequency response. The filter can be turned off for applications where the delay introduced by the filter is unwanted, e.g. time-based multiplexing
+
+### Updated DAC Pipeline
+- increased amplitude resolution of waveform signal components to 16-bit, decreasing the discretization of the sine amplitude from 122 µV to 15 µV
+- increase resolution of DAC pipeline to 16-bit until the final output quantization for improved accuracy when combining different components
+- prevent potential overflow in DAC pipeline when adding multiple components
+- reintroduced signal limiter, which was mistakenly removed in a previous release
+- removed hard limit of 1 V from amplitude components, as the DAC might be able to produce higher amplitudes depending on the calibration
+
+### General Updates
+- extended instant reset to ramp down the outputs if ramping is enabled instead of cutting
+- (re)added SCPI interface to enable instant reset
+- added 3-bit counter output with configurable counter speed outputting on DIO2_N (LSB) to DIO4_N (MSB)
+- Improved passing of error messages from SCPI server to the Julia client, SCPI errors still do not throw, but additional info is output as log messages
+- added `calibReset!(rp)` to reset ADC and DAC calibration to default
+- added `serverversion(rp)` to query the version of the server running of the RedPitaya
+- improved `imgversion` to not error on server versions prior to the introduction
+- added two examples on FIR switching
+- deprecated `enableRampDown!` and `enableRampDown` due to misleading names and functionality. Use `startRampDown!(rp, channel)` in the future to start a ramp down. It is not and was never possible to stop a triggered ramp down contrary to what the existence of `enableRampDown!(rp, channel, false)` might suggest.
+
+

Makefile

@@ -63,7 +63,7 @@ all: linux
 daq_bitfiles: $(addsuffix .bit, $(addprefix bitfiles/daq_,$(DAQ_PARTS)))
 
 bitfiles/daq_%.bit: daq_cores
-ifeq ("$(wildcard bitfiles/daq_$*.bit)","")
+ifneq ("$(wildcard bitfiles/daq_$*.bit)","")
 	vivado -nolog -nojournal -mode batch -source src/fpga/build.tcl -tclargs $*
 	vivado -nolog -nojournal -mode batch -source scripts/runSynthAndImpl.tcl -tclargs $*
 	mkdir -p bitfiles

docs/src/connections.md

@@ -12,4 +12,6 @@ The project uses most but not all connections that are used in the original RedP
 * `DIO4_P` outputs a high for 10 ms after a 100 ms pause on low to provide an alive signal.
 * `DIO5_P` can be set to high via the configuration register to provide the mutual trigger signal.
 * `DIO7_P`, `DIO7_N`, `DIO6_P`, `DIO6_N`, `DIO5_N`, `DIO4_N`, `DIO3_N`, `DIO2_N` can be used as arbitrary outputs set via the server.
+* `DIO2_N` (LSB) to `DIO4_N` (MSB) can output a 3-bit counter configurable by `counterSamplesPerStep!` (deactivate with 0)
 * `DIO0_N` and `DIO1_N` are used for the clock selection in a cluster.
+

docs/src/generation.md

@@ -1,14 +1,16 @@
 # Signal Generation
-Once the acquisition is triggered, each RedPitaya also starts producing signals on their output channels. Each RedPitaya features six such channels, two of those are the 16-bit DAC channel and four of those are digital pins using PDM, see [Connections](connections.md). The output signals are composed of three parts: parameterized waveforms ``W_i(t)``, an offset ``o_i`` and repeating arbitrary LUT tables. The latter are called sequences ``seq_i(t)``. The resulting signal of the DAC channel can be described as: 
+Once the acquisition is triggered, each RedPitaya also starts producing signals on their output channels. Each RedPitaya features six such channels, two of those are the 14-bit DAC channel and four of those are digital pins using PDM, see [Connections](connections.md). The output signals are composed of three parts: parameterized waveforms ``W_i(t)``, an offset ``o_i`` and repeating arbitrary LUT tables. The latter are called sequences ``seq_i(t)``. The resulting signal of the DAC channel can be described as: 
 
 ```math
 S_i(t) = seq_i(t) + o_i + W_i(t)
 ```
 ## Waveforms
-Each of the 16-bit DAC channel can output a compositve waveform with four components. Each component can be parametrized by its amplitude ``a_{i,j}``, frequency ``f_{i,j}`` and phase ``\varphi_{i,j}``, which can all be changed via SCPI commands. Furthermore, each component also offers different waveforms ``w_{i,j}``(sine, triangle, sawtooth):
+Each of the 14-bit DAC channels can output a compositve waveform with three components. Each component can be parametrized by its amplitude ``a_{i,j}``, frequency ``f_{i,j}`` and phase ``\varphi_{i,j}``, which can all be changed via SCPI commands. Furthermore, each component also offers different waveforms ``w_{i,j}``(sine, triangle, sawtooth):
 ```math
-W_i(t) = \sum_{j=1}^{4}a_{i,j} w_{i,j}(2\pi f_{i,j}t + \varphi_{i, j})
+W_i(t) = \sum_{j=1}^{3}a_{i,j} w_{i,j}(2\pi f_{i,j}t + \varphi_{i, j})
 ```
+
+Additionally there is a fourth waveform which can be user-configured to an arbitrary waveform. The arbitrary waveform is defined by a 16384 sample buffer representing a single period, which is then also parameterized using a frequency and phase. Note, that the amplitude of the waveform has to be adjusted by updating the buffer.
 ## Ramping
 The signals output on the DAC channel can also be multiplied with an increasing/decreasing ramping factor ``r(t)``. Ramping and the ramping duration can be enabled and set on a per channel basis. The increasing factor starts from 0 and goes to 1 from the acquisition start on. The decreasing factor goes from 1 to 0.
 

docs/src/scpi.md

@@ -89,7 +89,11 @@ During an active trigger the buffer is periodically updated by the server. If th
 |RP:CALib:DAC:CHannel#:OFFset? | channel (0, 1) | Return the DAC offset value for given channel from EEPROM | Any | RP:CAL:DAC:CH1:OFF? |
 |RP:CALib:DAC:CHannel#:SCAle | channel (0, 1), scale| Store the DAC scale value for given channel in EEPROM | C | RP:CAL:DAC:CH1:SCA 1.0 |
 |RP:CALib:DAC:CHannel#:SCAle? | channel (0, 1) | Return the DAC scale value for given channel from EEPROM | Any | RP:CAL:DAC:CH1:SCA? |
-
+|RP:CALib:DAC:CHannel#:LIMit:UPper | channel (0, 1), upper limit| Store the DAC upper limit value (in V) for given channel in EEPROM | C | RP:CAL:DAC:CH1:LIM:UP 1.0 |
+|RP:CALib:DAC:CHannel#:LIMit:UPper? | channel (0, 1) | Return the DAC upper limit value (in V) for given channel from EEPROM | Any | RP:CAL:DAC:CH1:LIM:UP? |
+|RP:CALib:DAC:CHannel#:LIMit:LOWer | channel (0, 1), lower limit| Store the DAC lower limit value (in V) for given channel in EEPROM | C | RP:CAL:DAC:CH1:LIM:LOW -1.0 |
+|RP:CALib:DAC:CHannel#:LIMit:LOWer? | channel (0, 1) | Return the DAC lower limit value (in V) for given channel from EEPROM | Any | RP:CAL:DAC:CH1:LIM:LOW? |
+|RP:CALib:RESet |  | Reset all EEPROM calibration values to their default | C | RP:CAL:RES |
 ## DIO
 
 | Command        | Arguments    | Description         | Example         |

src/client/julia/Project.toml

@@ -1,7 +1,7 @@
 name = "RedPitayaDAQServer"
 uuid = "c544963a-496b-56d4-a5fe-f99a3f174c8f"
 authors = ["Tobias Knopp <tobias@knoppweb.de>"]
-version = "0.10.0"
+version = "0.11.0"
 
 [deps]
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"

src/client/julia/src/ADC.jl

@@ -2,7 +2,7 @@ export TriggerMode, INTERNAL, EXTERNAL, ADCPerformanceData, RPStatus, Performanc
 decimation, decimation!, numChan, samplesPerPeriod, samplesPerPeriod!, periodsPerFrame, periodsPerFrame!,
 currentWP, currentPeriod, currentFrame, masterTrigger, masterTrigger!, keepAliveReset, keepAliveReset!,
 triggerMode, triggerMode!, overwritten, corrupted, serverStatus, performanceData,
-readSamples, startPipelinedData, stopTransmission, triggerPropagation, triggerPropagation!
+readSamples, startPipelinedData, stopTransmission, triggerPropagation, triggerPropagation!, firEnabled, firEnabled!
 
 """
     TriggerMode
@@ -280,6 +280,29 @@ scpiCommand(::typeof(keepAliveReset)) = "RP:TRIGger?"
 scpiReturn(::typeof(keepAliveReset)) = String
 parseReturn(::typeof(keepAliveReset), ret) = occursin("ON", ret)
 
+"""
+    firEnabled!(rp::RedPitaya, val::Bool)
+
+Set the firEnabled to `val`.
+"""
+function firEnabled!(rp::RedPitaya, val::Bool)
+  return query(rp, scpiCommand(firEnabled!, val), scpiReturn(firEnabled!))
+end
+scpiCommand(::typeof(firEnabled!), val::Bool) = scpiCommand(firEnabled!, val ? "ON" : "OFF")
+scpiCommand(::typeof(firEnabled!), val::String) = string("RP:ADC:FIREnabled ", val)
+scpiReturn(::typeof(firEnabled!)) = Bool
+"""
+    firEnabled(rp::RedPitaya)
+
+Determine whether the firEnabled is set.
+"""
+firEnabled(rp::RedPitaya) = occursin("ON", query(rp, scpiCommand(firEnabled)))
+scpiCommand(::typeof(firEnabled)) = "RP:ADC:FIREnabled?"
+scpiReturn(::typeof(firEnabled)) = String
+parseReturn(::typeof(firEnabled), ret) = occursin("ON", ret)
+
+
+
 
 # "INTERNAL" or "EXTERNAL"
 """

src/client/julia/src/Acquisition.jl

@@ -40,13 +40,15 @@ function readSamplesHeartbeat(rpu::Union{RedPitaya,RedPitayaCluster, RedPitayaCl
   end
 end
 
-correctFilterDelay(rpu::Union{RedPitaya, RedPitayaCluster}, wpStart) = correctFilterDelay(wpStart, decimation(rpu))
-correctFilterDelay(rpcv::RedPitayaClusterView, wpStart) = correctFilterDelay(rpcv.rpc, wpStart)
-function correctFilterDelay(wpStart::Int64, dec::Int64)
+correctFilterDelay(rpu::Union{RedPitaya, RedPitayaCluster}, wpStart; kwargs...) = correctFilterDelay(wpStart, decimation(rpu); fir_enabled=firEnabled(rpu), kwargs...)
+correctFilterDelay(rpcv::RedPitayaClusterView, wpStart; kwargs...) = correctFilterDelay(rpcv.rpc, wpStart; kwargs...)
+function correctFilterDelay(wpStart::Int64, dec::Int64; fir_enabled::Bool = true)
   cic_stages = 6
   fir_taps = 92
-  cicDelay = (((dec/2-1)/2*cic_stages))/dec
-  firDelay = ((fir_taps-1)/2)/2
+  dec_div = fir_enabled ? 2 : 1
+
+  cicDelay = fir_enabled ? ((((dec/dec_div-1)/2*cic_stages))/dec) : (dec-1)/2*cic_stages/dec
+  firDelay = fir_enabled ? (((fir_taps-1)/2)/2) : 0
   delay = Int64(round((cicDelay + firDelay), RoundUp))
   correctedWp = wpStart + delay
   @debug "Filter delay corrected $wpStart to $correctedWp ($cicDelay, $firDelay, $delay)"
@@ -66,7 +68,8 @@ Request and receive `numOfRequestedSamples` samples from `wpStart` on in a pipel
 
 If `rpInfo` is set to a `RPInfo`, the `PerformanceData` sent after every `chunkSize` samples will be pushed into `rpInfo`.
 """
-function readSamples(rpu::Union{RedPitaya,RedPitayaCluster, RedPitayaClusterView}, wpStart::Int64, numOfRequestedSamples::Int64; chunkSize::Int64 = 25000, rpInfo=nothing, correct_filter_delay::Bool = true)
+function readSamples(rpu::Union{RedPitaya,RedPitayaCluster, RedPitayaClusterView}, wpStart::Int64, numOfRequestedSamples::Int64; 
+                     chunkSize::Int64 = 25000, rpInfo=nothing, correct_filter_delay::Bool = true)
   numOfReceivedSamples = 0
   index = 1
   rawData = zeros(Int16, numChan(rpu), numOfRequestedSamples)
@@ -109,7 +112,8 @@ Request and receive `numOfRequestedSamples` samples from `wpStart` on in a pipel
 
 See [`SampleChunk`](@ref).
 """
-function readSamples(rpu::Union{RedPitaya,RedPitayaCluster, RedPitayaClusterView}, wpStart::Int64, numOfRequestedSamples::Int64, channel::Channel; chunkSize::Int64 = 25000, correct_filter_delay::Bool = true)
+function readSamples(rpu::Union{RedPitaya,RedPitayaCluster, RedPitayaClusterView}, wpStart::Int64, numOfRequestedSamples::Int64, channel::Channel; 
+                     chunkSize::Int64 = 25000, correct_filter_delay::Bool = true)
   numOfReceivedSamples = 0
   chunkBuffer = zeros(Int16, chunkSize * 2, length(rpu))
 
@@ -189,7 +193,7 @@ See [`readSamples`](@ref), [`convertSamplesToFrames`](@ref), [`samplesPerPeriod`
 - `rpInfo=nothing`: see `readSamples`
 - `useCalibration`: convert from Int16 samples to Float32 values based on `RedPitaya`s calibration
 """
-function readFrames(rpu::Union{RedPitaya,RedPitayaCluster, RedPitayaClusterView}, startFrame, numFrames, numBlockAverages=1, numPeriodsPerPatch=1; rpInfo=nothing, chunkSize = 50000, useCalibration = false, correct_filter_delay::Bool = true)
+function readFrames(rpu::Union{RedPitaya,RedPitayaCluster, RedPitayaClusterView}, startFrame, numFrames, numBlockAverages=1, numPeriodsPerPatch=1; useCalibration = false, kwargs...)
   numSampPerPeriod = samplesPerPeriod(rpu)
   numPeriods = periodsPerFrame(rpu)
   numSampPerFrame = numSampPerPeriod * numPeriods
@@ -202,7 +206,7 @@ function readFrames(rpu::Union{RedPitaya,RedPitayaCluster, RedPitayaClusterView}
   numOfRequestedSamples = numFrames * numSampPerFrame
 
   # rawSamples Int16 numofChan(rpc) x numOfRequestedSamples
-  rawSamples = readSamples(rpu, Int64(wpStart), Int64(numOfRequestedSamples), chunkSize = chunkSize, rpInfo = rpInfo, correct_filter_delay = correct_filter_delay)
+  rawSamples = readSamples(rpu, Int64(wpStart), Int64(numOfRequestedSamples); kwargs...)
 
   # Reshape/Avg Data
   if useCalibration
@@ -302,7 +306,7 @@ See [`readSamples`](@ref), [`convertSamplesToPeriods!`](@ref), [`samplesPerPerio
 - `rpInfo=nothing`: see `readSamples`
 - `useCalibration`: convert samples based on `RedPitaya`s calibration
 """
-function readPeriods(rpu::Union{RedPitaya,RedPitayaCluster, RedPitayaClusterView}, startPeriod, numPeriods, numBlockAverages=1; rpInfo=nothing, chunkSize = 50000, useCalibration = false, correct_filter_delay::Bool = true)
+function readPeriods(rpu::Union{RedPitaya,RedPitayaCluster, RedPitayaClusterView}, startPeriod, numPeriods, numBlockAverages=1; useCalibration = false, kwargs...)
   numSampPerPeriod = samplesPerPeriod(rpu)
 
   if rem(numSampPerPeriod,numBlockAverages) != 0
@@ -316,7 +320,7 @@ function readPeriods(rpu::Union{RedPitaya,RedPitayaCluster, RedPitayaClusterView
   numOfRequestedSamples = numPeriods * numSampPerPeriod
 
   # rawSamples Int16 numofChan(rpc) x numOfRequestedSamples
-  rawSamples = readSamples(rpu, Int64(wpStart), Int64(numOfRequestedSamples), chunkSize = chunkSize, rpInfo = rpInfo, correct_filter_delay = correct_filter_delay)
+  rawSamples = readSamples(rpu, Int64(wpStart), Int64(numOfRequestedSamples); kwargs...)
 
   # Reshape/Avg Data
   if useCalibration

src/client/julia/src/Cluster.jl

@@ -52,6 +52,7 @@ function RedPitayaCluster(hosts::Vector{String}, port::Int64=5025, dataPort::Int
 
   @sync for (i, rp) ∈ enumerate(rps)
     @async begin
+      serverMode!(rp, CONFIGURATION)
       triggerMode!(rp, modes[i])
       triggerPropagation!(rp, true)
     end
@@ -103,7 +104,7 @@ function RPInfo(rpc::RedPitayaCluster)
 end
 
 for op in [:currentFrame, :currentPeriod, :currentWP, :periodsPerFrame, :samplesPerPeriod, :decimation, :keepAliveReset,
-           :triggerMode, :samplesPerStep, :serverMode, :masterTrigger,
+           :triggerMode, :samplesPerStep, :serverMode, :masterTrigger, :firEnabled,
            :counterTrigger_enabled, :counterTrigger_enabled!, :counterTrigger_presamples,
            :counterTrigger_isArmed, :counterTrigger_arm!, :counterTrigger_reset!,
            :counterTrigger_reset, :counterTrigger_lastCounter, :counterTrigger_referenceCounter,
@@ -121,10 +122,10 @@ for op in [:currentFrame, :currentPeriod, :currentWP, :periodsPerFrame, :samples
 end
 
 for op in [:periodsPerFrame!, :samplesPerPeriod!, :decimation!, :triggerMode!, :samplesPerStep!,
-           :keepAliveReset!, :serverMode!,
+           :keepAliveReset!, :serverMode!, :firEnabled!,
            :counterTrigger_enabled!, :counterTrigger_presamples!, :counterTrigger_arm!,
            :counterTrigger_reset!, :counterTrigger_referenceCounter!,
-           :counterTrigger_sourceType!, :counterTrigger_sourceChannel!]
+           :counterTrigger_sourceType!, :counterTrigger_sourceChannel!, :enableInstantReset!]
   @eval begin
     @doc """
         $($op)(rpc::RedPitayaCluster, value)
@@ -142,7 +143,7 @@ for op in [:periodsPerFrame!, :samplesPerPeriod!, :decimation!, :triggerMode!, :
   end
 end
 
-for op in [:clearSequence!, :sequence!, :stopTransmission]
+for op in [:clearSequence!, :sequence!, :stopTransmission, :enableInstantReset, :instantResetTriggered]
   @eval begin
     @doc """
         $($op)(rpc::RedPitayaCluster)
@@ -234,7 +235,7 @@ for op in [:signalTypeDAC!, :amplitudeDAC!, :frequencyDAC!, :phaseDAC!]
   end
 end
 
-for op in [:offsetDAC, :rampingDAC, :enableRamping, :enableRampDown]
+for op in [:offsetDAC, :rampingDAC, :enableRamping, :enableRampDown, :startRampDown!]
   @eval begin
     @doc """
         $($op)(rpc::RedPitayaCluster, chan::Integer)