Skip to content
Permalink

Comparing changes

Choose two branches to see what’s changed or to start a new pull request. If you need to, you can also or learn more about diff comparisons.

Open a pull request

Create a new pull request by comparing changes across two branches. If you need to, you can also . Learn more about diff comparisons here.
base repository: ngscopeclient/scopehal
Failed to load repositories. Confirm that selected base ref is valid, then try again.
Loading
base: c7c77ed95303
Choose a base ref
...
head repository: ngscopeclient/scopehal
Failed to load repositories. Confirm that selected head ref is valid, then try again.
Loading
compare: db4d095b367d
Choose a head ref
  • 3 commits
  • 13 files changed
  • 1 contributor

Commits on May 24, 2020

  1. Copy the full SHA
    46dcb36 View commit details
  2. Copy the full SHA
    429dd58 View commit details
  3. Copy the full SHA
    db4d095 View commit details
21 changes: 0 additions & 21 deletions scopemeasurements/CMakeLists.txt

This file was deleted.

50 changes: 0 additions & 50 deletions scopemeasurements/scopemeasurements.cpp

This file was deleted.

49 changes: 0 additions & 49 deletions scopemeasurements/scopemeasurements.h

This file was deleted.

3 changes: 3 additions & 0 deletions scopeprotocols/CMakeLists.txt
Original file line number Diff line number Diff line change
@@ -34,8 +34,10 @@ set(SCOPEPROTOCOLS_SOURCES
JtagDecoder.cpp
MDIODecoder.cpp
MovingAverageDecoder.cpp
OvershootMeasurementDecoder.cpp
ParallelBusDecoder.cpp
PeriodMeasurementDecoder.cpp
PkPkMeasurementDecoder.cpp
RiseMeasurementDecoder.cpp
SincInterpolationDecoder.cpp
SPIDecoder.cpp
@@ -44,6 +46,7 @@ set(SCOPEPROTOCOLS_SOURCES
TopMeasurementDecoder.cpp
UARTDecoder.cpp
UartClockRecoveryDecoder.cpp
UndershootMeasurementDecoder.cpp
USB2ActivityDecoder.cpp
USB2PacketDecoder.cpp
USB2PCSDecoder.cpp
Original file line number Diff line number Diff line change
@@ -2,7 +2,7 @@
* *
* ANTIKERNEL v0.1 *
* *
* Copyright (c) 2012-2019 Andrew D. Zonenberg *
* Copyright (c) 2012-2020 Andrew D. Zonenberg *
* All rights reserved. *
* *
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the *
@@ -27,68 +27,163 @@
* *
***********************************************************************************************************************/

/**
@file
@author Andrew D. Zonenberg
@brief Declaration of OvershootMeasurement
*/

#include "scopemeasurements.h"
#include "OvershootMeasurement.h"
#include "scopeprotocols.h"
#include "OvershootMeasurementDecoder.h"

using namespace std;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Construction/destruction
// Construction / destruction

OvershootMeasurement::OvershootMeasurement()
: FloatMeasurement(TYPE_PERCENTAGE)
OvershootMeasurementDecoder::OvershootMeasurementDecoder(string color)
: ProtocolDecoder(OscilloscopeChannel::CHANNEL_TYPE_ANALOG, color, CAT_MEASUREMENT)
{
//Configure for a single input
m_signalNames.push_back("Vin");
//Set up channels
m_signalNames.push_back("din");
m_channels.push_back(NULL);

m_midpoint = 0;
m_range = 1;
}

OvershootMeasurement::~OvershootMeasurement()
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Factory methods

bool OvershootMeasurementDecoder::ValidateChannel(size_t i, OscilloscopeChannel* channel)
{
if( (i == 0) && (channel->GetType() == OscilloscopeChannel::CHANNEL_TYPE_ANALOG) )
return true;
return false;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Accessors

Measurement::MeasurementType OvershootMeasurement::GetMeasurementType()
void OvershootMeasurementDecoder::SetDefaultName()
{
return Measurement::MEAS_VERT;
char hwname[256];
snprintf(hwname, sizeof(hwname), "Overshoot(%s)", m_channels[0]->m_displayname.c_str());
m_hwname = hwname;
m_displayname = m_hwname;
}

string OvershootMeasurement::GetMeasurementName()
string OvershootMeasurementDecoder::GetProtocolName()
{
return "Overshoot";
}

bool OvershootMeasurement::ValidateChannel(size_t i, OscilloscopeChannel* channel)
bool OvershootMeasurementDecoder::IsOverlay()
{
if( (i == 0) && (channel->GetType() == OscilloscopeChannel::CHANNEL_TYPE_ANALOG) )
return true;
//we create a new analog channel
return false;
}

bool OvershootMeasurementDecoder::NeedsConfig()
{
//automatic configuration
return false;
}

double OvershootMeasurementDecoder::GetVoltageRange()
{
return m_range;
}

double OvershootMeasurementDecoder::GetOffset()
{
return -m_midpoint;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Measurement processing
// Actual decoder logic

bool OvershootMeasurement::Refresh()
void OvershootMeasurementDecoder::Refresh()
{
//Get the input data
if(m_channels[0] == NULL)
return false;
AnalogCapture* din = dynamic_cast<AnalogCapture*>(m_channels[0]->GetData());
if(din == NULL || (din->GetDepth() == 0))
return false;

//Calculate the worst case overshoot
float max = GetMaxVoltage(din);
float top = GetTopVoltage(din);
float base = GetBaseVoltage(din);
m_value = (max-top) / (top-base);
return true;
{
SetData(NULL);
return;
}
auto din = dynamic_cast<AnalogWaveform*>(m_channels[0]->GetData());
if(din == NULL)
{
SetData(NULL);
return;
}

//We need meaningful data
size_t len = din->m_samples.size();
if(len == 0)
{
SetData(NULL);
return;
}

//Figure out the nominal top of the waveform
float top = Measurement::GetTopVoltage(din);
float base = Measurement::GetBaseVoltage(din);
float midpoint = (top+base)/2;

//Create the output
auto cap = new AnalogWaveform;

float fmax = -FLT_MAX;
float fmin = FLT_MAX;

int64_t tmax = 0;
float vmax = 0;

//For each cycle, find how far we got above the top
for(size_t i=0; i < len; i++)
{
//If we're below the midpoint, reset everything and add a new sample
float v = din->m_samples[i];
if(v < midpoint)
{
//Add a sample for the current value (if any)
if(tmax > 0)
{
//Update duration of the previous sample
size_t off = cap->m_offsets.size();
if(off > 0)
cap->m_durations[off-1] = tmax - cap->m_offsets[off-1];

float value = vmax - top;
fmax = max(fmax, value);
fmin = min(fmin, value);

//Add the new sample
cap->m_offsets.push_back(tmax);
cap->m_durations.push_back(0);
cap->m_samples.push_back(value);
}

//Reset
tmax = 0;
vmax = -FLT_MAX;
}

//Accumulate the highest peak of this cycle
else
{
if(v > vmax)
{
tmax = din->m_offsets[i];
vmax = v;
}
}
}

m_range = fmax - fmin;
if(m_range < 0.025)
m_range = 0.025;
m_midpoint = (fmax + fmin) / 2;

SetData(cap);

//Copy start time etc from the input.
cap->m_timescale = din->m_timescale;
cap->m_startTimestamp = din->m_startTimestamp;
cap->m_startPicoseconds = din->m_startPicoseconds;
}
Original file line number Diff line number Diff line change
@@ -2,7 +2,7 @@
* *
* ANTIKERNEL v0.1 *
* *
* Copyright (c) 2012-2019 Andrew D. Zonenberg *
* Copyright (c) 2012-2020 Andrew D. Zonenberg *
* All rights reserved. *
* *
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the *
@@ -30,27 +30,36 @@
/**
@file
@author Andrew D. Zonenberg
@brief Declaration of UndershootMeasurement
@brief Declaration of OvershootMeasurementDecoder
*/
#ifndef UndershootMeasurement_h
#define UndershootMeasurement_h
#ifndef OvershootMeasurementDecoder_h
#define OvershootMeasurementDecoder_h

#include "../scopehal/Measurement.h"
#include "../scopehal/ProtocolDecoder.h"

class UndershootMeasurement : public FloatMeasurement
class OvershootMeasurementDecoder : public ProtocolDecoder
{
public:
UndershootMeasurement();
virtual ~UndershootMeasurement();
OvershootMeasurementDecoder(std::string color);

virtual bool Refresh();
virtual void Refresh();

virtual bool NeedsConfig();
virtual bool IsOverlay();

static std::string GetProtocolName();
virtual void SetDefaultName();

virtual double GetVoltageRange();
virtual double GetOffset();

static std::string GetMeasurementName();
virtual bool ValidateChannel(size_t i, OscilloscopeChannel* channel);

virtual MeasurementType GetMeasurementType();
PROTOCOL_DECODER_INITPROC(OvershootMeasurementDecoder)

MEASUREMENT_INITPROC(UndershootMeasurement)
protected:
double m_midpoint;
double m_range;
};

#endif
Original file line number Diff line number Diff line change
@@ -2,7 +2,7 @@
* *
* ANTIKERNEL v0.1 *
* *
* Copyright (c) 2012-2019 Andrew D. Zonenberg *
* Copyright (c) 2012-2020 Andrew D. Zonenberg *
* All rights reserved. *
* *
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the *
@@ -27,65 +27,180 @@
* *
***********************************************************************************************************************/

/**
@file
@author Andrew D. Zonenberg
@brief Declaration of PkPkVoltageMeasurement
*/

#include "scopemeasurements.h"
#include "PkPkVoltageMeasurement.h"
#include "scopeprotocols.h"
#include "PkPkMeasurementDecoder.h"

using namespace std;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Construction/destruction
// Construction / destruction

PkPkVoltageMeasurement::PkPkVoltageMeasurement()
: FloatMeasurement(TYPE_VOLTAGE)
PkPkMeasurementDecoder::PkPkMeasurementDecoder(string color)
: ProtocolDecoder(OscilloscopeChannel::CHANNEL_TYPE_ANALOG, color, CAT_MEASUREMENT)
{
//Configure for a single input
m_signalNames.push_back("Vin");
//Set up channels
m_signalNames.push_back("din");
m_channels.push_back(NULL);

m_midpoint = 0;
m_range = 1;
}

PkPkVoltageMeasurement::~PkPkVoltageMeasurement()
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Factory methods

bool PkPkMeasurementDecoder::ValidateChannel(size_t i, OscilloscopeChannel* channel)
{
if( (i == 0) && (channel->GetType() == OscilloscopeChannel::CHANNEL_TYPE_ANALOG) )
return true;
return false;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Accessors

Measurement::MeasurementType PkPkVoltageMeasurement::GetMeasurementType()
void PkPkMeasurementDecoder::SetDefaultName()
{
return Measurement::MEAS_VERT;
char hwname[256];
snprintf(hwname, sizeof(hwname), "PkPk(%s)", m_channels[0]->m_displayname.c_str());
m_hwname = hwname;
m_displayname = m_hwname;
}

string PkPkVoltageMeasurement::GetMeasurementName()
string PkPkMeasurementDecoder::GetProtocolName()
{
return "Pk-Pk";
return "Peak-to-Peak";
}

bool PkPkVoltageMeasurement::ValidateChannel(size_t i, OscilloscopeChannel* channel)
bool PkPkMeasurementDecoder::IsOverlay()
{
if( (i == 0) && (channel->GetType() == OscilloscopeChannel::CHANNEL_TYPE_ANALOG) )
return true;
//we create a new analog channel
return false;
}

bool PkPkMeasurementDecoder::NeedsConfig()
{
//automatic configuration
return false;
}

double PkPkMeasurementDecoder::GetVoltageRange()
{
return m_range;
}

double PkPkMeasurementDecoder::GetOffset()
{
return -m_midpoint;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Measurement processing
// Actual decoder logic

bool PkPkVoltageMeasurement::Refresh()
void PkPkMeasurementDecoder::Refresh()
{
//Get the input data
if(m_channels[0] == NULL)
return false;
AnalogCapture* din = dynamic_cast<AnalogCapture*>(m_channels[0]->GetData());
if(din == NULL || (din->GetDepth() == 0))
return false;

//Calculate the global peak to peak
m_value = GetMaxVoltage(din) - GetMinVoltage(din);
return true;
{
SetData(NULL);
return;
}
auto din = dynamic_cast<AnalogWaveform*>(m_channels[0]->GetData());
if(din == NULL)
{
SetData(NULL);
return;
}

//We need meaningful data
size_t len = din->m_samples.size();
if(len == 0)
{
SetData(NULL);
return;
}

//Figure out the nominal midpoint of the waveform
float top = Measurement::GetTopVoltage(din);
float base = Measurement::GetBaseVoltage(din);
float midpoint = (top+base)/2;

//Create the output
auto cap = new AnalogWaveform;

float fmax = -FLT_MAX;
float fmin = FLT_MAX;

int64_t tmin = 0;
float vmin = FLT_MAX;
float vmax = -FLT_MAX;
float last_max = -FLT_MAX;

//For each cycle, find the min and max
bool last_was_low = true;
for(size_t i=0; i < len; i++)
{
//If we're above the midpoint, reset everything and add a new sample
float v = din->m_samples[i];
if(v > midpoint)
{
last_was_low = false;

//Add a sample for the current value (if any)
if( (tmin > 0) && (last_max > -FLT_MAX/2) )
{
//Update duration of the previous sample
size_t off = cap->m_offsets.size();
if(off > 0)
cap->m_durations[off-1] = tmin - cap->m_offsets[off-1];

float value = last_max - vmin;

fmax = max(fmax, value);
fmin = min(fmin, value);

//Add the new sample
cap->m_offsets.push_back(tmin);
cap->m_durations.push_back(0);
cap->m_samples.push_back(value);
}

//Reset
tmin = 0;
vmin = FLT_MAX;

//Accumulate
vmax = max(vmax, v);
}

//Accumulate the lowest peak of this cycle
//and save the
else
{
if(!last_was_low)
{
last_max = vmax;
vmax = -FLT_MAX;
last_was_low = true;
}

if(v < vmin)
{
tmin = din->m_offsets[i];
vmin = v;
}
}
}

m_range = fmax - fmin;
if(m_range < 0.025)
m_range = 0.025;
m_midpoint = (fmax + fmin) / 2;

SetData(cap);

//Copy start time etc from the input.
cap->m_timescale = din->m_timescale;
cap->m_startTimestamp = din->m_startTimestamp;
cap->m_startPicoseconds = din->m_startPicoseconds;
}
Original file line number Diff line number Diff line change
@@ -2,7 +2,7 @@
* *
* ANTIKERNEL v0.1 *
* *
* Copyright (c) 2012-2019 Andrew D. Zonenberg *
* Copyright (c) 2012-2020 Andrew D. Zonenberg *
* All rights reserved. *
* *
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the *
@@ -30,27 +30,36 @@
/**
@file
@author Andrew D. Zonenberg
@brief Declaration of PkPkVoltageMeasurement
@brief Declaration of PkPkMeasurementDecoder
*/
#ifndef PkPkVoltageMeasurement_h
#define PkPkVoltageMeasurement_h
#ifndef PkPkMeasurementDecoder_h
#define PkPkMeasurementDecoder_h

#include "../scopehal/Measurement.h"
#include "../scopehal/ProtocolDecoder.h"

class PkPkVoltageMeasurement : public FloatMeasurement
class PkPkMeasurementDecoder : public ProtocolDecoder
{
public:
PkPkVoltageMeasurement();
virtual ~PkPkVoltageMeasurement();
PkPkMeasurementDecoder(std::string color);

virtual bool Refresh();
virtual void Refresh();

virtual bool NeedsConfig();
virtual bool IsOverlay();

static std::string GetProtocolName();
virtual void SetDefaultName();

virtual double GetVoltageRange();
virtual double GetOffset();

static std::string GetMeasurementName();
virtual bool ValidateChannel(size_t i, OscilloscopeChannel* channel);

virtual MeasurementType GetMeasurementType();
PROTOCOL_DECODER_INITPROC(PkPkMeasurementDecoder)

MEASUREMENT_INITPROC(PkPkVoltageMeasurement)
protected:
double m_midpoint;
double m_range;
};

#endif
2 changes: 1 addition & 1 deletion scopeprotocols/TopMeasurementDecoder.cpp
Original file line number Diff line number Diff line change
@@ -159,7 +159,7 @@ void TopMeasurementDecoder::Refresh()

for(size_t i=0; i < len; i++)
{
//Wait for a falling edge
//Wait for a rising edge
float cur = din->m_samples[i];
int64_t tnow = din->m_offsets[i] * din->m_timescale;

Original file line number Diff line number Diff line change
@@ -2,7 +2,7 @@
* *
* ANTIKERNEL v0.1 *
* *
* Copyright (c) 2012-2019 Andrew D. Zonenberg *
* Copyright (c) 2012-2020 Andrew D. Zonenberg *
* All rights reserved. *
* *
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the *
@@ -27,68 +27,163 @@
* *
***********************************************************************************************************************/

/**
@file
@author Andrew D. Zonenberg
@brief Declaration of UndershootMeasurement
*/

#include "scopemeasurements.h"
#include "UndershootMeasurement.h"
#include "scopeprotocols.h"
#include "UndershootMeasurementDecoder.h"

using namespace std;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Construction/destruction
// Construction / destruction

UndershootMeasurement::UndershootMeasurement()
: FloatMeasurement(TYPE_PERCENTAGE)
UndershootMeasurementDecoder::UndershootMeasurementDecoder(string color)
: ProtocolDecoder(OscilloscopeChannel::CHANNEL_TYPE_ANALOG, color, CAT_MEASUREMENT)
{
//Configure for a single input
m_signalNames.push_back("Vin");
//Set up channels
m_signalNames.push_back("din");
m_channels.push_back(NULL);

m_midpoint = 0;
m_range = 1;
}

UndershootMeasurement::~UndershootMeasurement()
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Factory methods

bool UndershootMeasurementDecoder::ValidateChannel(size_t i, OscilloscopeChannel* channel)
{
if( (i == 0) && (channel->GetType() == OscilloscopeChannel::CHANNEL_TYPE_ANALOG) )
return true;
return false;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Accessors

Measurement::MeasurementType UndershootMeasurement::GetMeasurementType()
void UndershootMeasurementDecoder::SetDefaultName()
{
return Measurement::MEAS_VERT;
char hwname[256];
snprintf(hwname, sizeof(hwname), "Undershoot(%s)", m_channels[0]->m_displayname.c_str());
m_hwname = hwname;
m_displayname = m_hwname;
}

string UndershootMeasurement::GetMeasurementName()
string UndershootMeasurementDecoder::GetProtocolName()
{
return "Undershoot";
}

bool UndershootMeasurement::ValidateChannel(size_t i, OscilloscopeChannel* channel)
bool UndershootMeasurementDecoder::IsOverlay()
{
if( (i == 0) && (channel->GetType() == OscilloscopeChannel::CHANNEL_TYPE_ANALOG) )
return true;
//we create a new analog channel
return false;
}

bool UndershootMeasurementDecoder::NeedsConfig()
{
//automatic configuration
return false;
}

double UndershootMeasurementDecoder::GetVoltageRange()
{
return m_range;
}

double UndershootMeasurementDecoder::GetOffset()
{
return -m_midpoint;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Measurement processing
// Actual decoder logic

bool UndershootMeasurement::Refresh()
void UndershootMeasurementDecoder::Refresh()
{
//Get the input data
if(m_channels[0] == NULL)
return false;
AnalogCapture* din = dynamic_cast<AnalogCapture*>(m_channels[0]->GetData());
if(din == NULL || (din->GetDepth() == 0))
return false;

//Calculate the worst case undershoot
float min = GetMinVoltage(din);
float top = GetTopVoltage(din);
float base = GetBaseVoltage(din);
m_value = (base-min) / (top-base);
return true;
{
SetData(NULL);
return;
}
auto din = dynamic_cast<AnalogWaveform*>(m_channels[0]->GetData());
if(din == NULL)
{
SetData(NULL);
return;
}

//We need meaningful data
size_t len = din->m_samples.size();
if(len == 0)
{
SetData(NULL);
return;
}

//Figure out the nominal top of the waveform
float top = Measurement::GetTopVoltage(din);
float base = Measurement::GetBaseVoltage(din);
float midpoint = (top+base)/2;

//Create the output
auto cap = new AnalogWaveform;

float fmax = -FLT_MAX;
float fmin = FLT_MAX;

int64_t tmin = 0;
float vmin = FLT_MAX;

//For each cycle, find how far we got below the base
for(size_t i=0; i < len; i++)
{
//If we're above the midpoint, reset everything and add a new sample
float v = din->m_samples[i];
if(v > midpoint)
{
//Add a sample for the current value (if any)
if(tmin > 0)
{
//Update duration of the previous sample
size_t off = cap->m_offsets.size();
if(off > 0)
cap->m_durations[off-1] = tmin - cap->m_offsets[off-1];

float value = base - vmin;
fmax = max(fmax, value);
fmin = min(fmin, value);

//Add the new sample
cap->m_offsets.push_back(tmin);
cap->m_durations.push_back(0);
cap->m_samples.push_back(value);
}

//Reset
tmin = 0;
vmin = FLT_MAX;
}

//Accumulate the lowest peak of this cycle
else
{
if(v < vmin)
{
tmin = din->m_offsets[i];
vmin = v;
}
}
}

m_range = fmax - fmin;
if(m_range < 0.025)
m_range = 0.025;
m_midpoint = (fmax + fmin) / 2;

SetData(cap);

//Copy start time etc from the input.
cap->m_timescale = din->m_timescale;
cap->m_startTimestamp = din->m_startTimestamp;
cap->m_startPicoseconds = din->m_startPicoseconds;
}
Original file line number Diff line number Diff line change
@@ -2,7 +2,7 @@
* *
* ANTIKERNEL v0.1 *
* *
* Copyright (c) 2012-2019 Andrew D. Zonenberg *
* Copyright (c) 2012-2020 Andrew D. Zonenberg *
* All rights reserved. *
* *
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the *
@@ -30,27 +30,36 @@
/**
@file
@author Andrew D. Zonenberg
@brief Declaration of OvershootMeasurement
@brief Declaration of UndershootMeasurementDecoder
*/
#ifndef OvershootMeasurement_h
#define OvershootMeasurement_h
#ifndef UndershootMeasurementDecoder_h
#define UndershootMeasurementDecoder_h

#include "../scopehal/Measurement.h"
#include "../scopehal/ProtocolDecoder.h"

class OvershootMeasurement : public FloatMeasurement
class UndershootMeasurementDecoder : public ProtocolDecoder
{
public:
OvershootMeasurement();
virtual ~OvershootMeasurement();
UndershootMeasurementDecoder(std::string color);

virtual bool Refresh();
virtual void Refresh();

virtual bool NeedsConfig();
virtual bool IsOverlay();

static std::string GetProtocolName();
virtual void SetDefaultName();

virtual double GetVoltageRange();
virtual double GetOffset();

static std::string GetMeasurementName();
virtual bool ValidateChannel(size_t i, OscilloscopeChannel* channel);

virtual MeasurementType GetMeasurementType();
PROTOCOL_DECODER_INITPROC(UndershootMeasurementDecoder)

MEASUREMENT_INITPROC(OvershootMeasurement)
protected:
double m_midpoint;
double m_range;
};

#endif
3 changes: 3 additions & 0 deletions scopeprotocols/scopeprotocols.cpp
Original file line number Diff line number Diff line change
@@ -71,7 +71,9 @@ void ScopeProtocolStaticInit()
AddDecoderClass(JtagDecoder);
AddDecoderClass(MDIODecoder);
AddDecoderClass(MovingAverageDecoder);
AddDecoderClass(OvershootMeasurementDecoder);
AddDecoderClass(ParallelBusDecoder);
AddDecoderClass(PkPkMeasurementDecoder);
AddDecoderClass(PeriodMeasurementDecoder);
AddDecoderClass(RiseMeasurementDecoder);
AddDecoderClass(SincInterpolationDecoder);
@@ -81,6 +83,7 @@ void ScopeProtocolStaticInit()
AddDecoderClass(TopMeasurementDecoder);
AddDecoderClass(UARTDecoder);
AddDecoderClass(UartClockRecoveryDecoder);
AddDecoderClass(UndershootMeasurementDecoder);
AddDecoderClass(USB2ActivityDecoder);
AddDecoderClass(USB2PacketDecoder);
AddDecoderClass(USB2PCSDecoder);
3 changes: 3 additions & 0 deletions scopeprotocols/scopeprotocols.h
Original file line number Diff line number Diff line change
@@ -72,7 +72,9 @@
#include "JtagDecoder.h"
#include "MDIODecoder.h"
#include "MovingAverageDecoder.h"
#include "OvershootMeasurementDecoder.h"
#include "ParallelBusDecoder.h"
#include "PkPkMeasurementDecoder.h"
#include "PeriodMeasurementDecoder.h"
#include "RiseMeasurementDecoder.h"
#include "SincInterpolationDecoder.h"
@@ -82,6 +84,7 @@
#include "TopMeasurementDecoder.h"
#include "UARTDecoder.h"
#include "UartClockRecoveryDecoder.h"
#include "UndershootMeasurementDecoder.h"
#include "USB2ActivityDecoder.h"
#include "USB2PacketDecoder.h"
#include "USB2PCSDecoder.h"