ISO14443AnalyzerSettings::ISO14443AnalyzerSettings()
: mInputChannel( UNDEFINED_CHANNEL ),
mBitRate( 9600 )
{
mInputChannelInterface.reset( new AnalyzerSettingInterfaceChannel() );
mInputChannelInterface->SetTitleAndTooltip( "DEMOD Channel", "On which Channel is the DEMOD connected?" );
mInputChannelInterface->SetChannel( mInputChannel );
mBitRateInterface.reset( new AnalyzerSettingInterfaceInteger() );
mBitRateInterface->SetTitleAndTooltip( "Bit Rate (Bits/S)", "Specify the bit rate in bits per second." );
mBitRateInterface->SetMax( 6000000 );
mBitRateInterface->SetMin( 1 );
mBitRateInterface->SetInteger( mBitRate );
AddInterface( mInputChannelInterface.get() );
//AddInterface( mBitRateInterface.get() );
AddExportOption( 0, "Export as text/csv file" );
AddExportExtension( 0, "text", "txt" );
AddExportExtension( 0, "csv", "csv" );
ClearChannels();
AddChannel( mInputChannel, "Serial", false );
}
void SpiAnalyzerSettings::LoadSettings( const char* settings )
{
SimpleArchive text_archive;
text_archive.SetString( settings );
const char* name_string; //the first thing in the archive is the name of the protocol analyzer that the data belongs to.
text_archive >> &name_string;
if( strcmp( name_string, "SaleaeSpiAnalyzer" ) != 0 )
AnalyzerHelpers::Assert( "SaleaeSpiAnalyzer: Provided with a settings string that doesn't belong to us;" );
text_archive >> mMosiChannel;
text_archive >> mMisoChannel;
text_archive >> mClockChannel;
text_archive >> mEnableChannel;
text_archive >> *(U32*)&mShiftOrder;
text_archive >> mBitsPerTransfer;
text_archive >> *(U32*)&mClockInactiveState;
text_archive >> *(U32*)&mDataValidEdge;
text_archive >> *(U32*)&mEnableActiveState;
//bool success = text_archive >> mUsePackets; //new paramater added -- do this for backwards compatibility
//if( success == false )
// mUsePackets = false; //if the archive fails, set the default value
ClearChannels();
AddChannel( mMosiChannel, "MOSI", mMosiChannel != UNDEFINED_CHANNEL );
AddChannel( mMisoChannel, "MISO", mMisoChannel != UNDEFINED_CHANNEL );
AddChannel( mClockChannel, "CLOCK", mClockChannel != UNDEFINED_CHANNEL );
AddChannel( mEnableChannel, "ENABLE", mEnableChannel != UNDEFINED_CHANNEL );
UpdateInterfacesFromSettings();
}
void SerialAnalyzerSettings::LoadSettings( const char* settings )
{
SimpleArchive text_archive;
text_archive.SetString( settings );
const char* name_string; //the first thing in the archive is the name of the protocol analyzer that the data belongs to.
text_archive >> &name_string;
if( strcmp( name_string, "SaleaeAsyncSerialAnalyzer" ) != 0 )
AnalyzerHelpers::Assert( "SaleaeAsyncSerialAnalyzer: Provided with a settings string that doesn't belong to us;" );
text_archive >> mInputChannel;
text_archive >> mBitRate;
text_archive >> mBitsPerTransfer;
text_archive >> mStopBits;
text_archive >> *(U32*)&mParity;
text_archive >> *(U32*)&mShiftOrder;
text_archive >> mInverted;
//check to make sure loading it actual works befor assigning the result -- do this when adding settings to an anylzer which has been previously released.
bool use_autobaud;
if( text_archive >> use_autobaud )
mUseAutobaud = use_autobaud;
SerialAnalyzerEnums::Mode mode;
if( text_archive >> *(U32*)&mode )
mSerialMode = mode;
ClearChannels();
AddChannel( mInputChannel, "Serial", true );
UpdateInterfacesFromSettings();
}
AtmelSWIAnalyzerSettings::AtmelSWIAnalyzerSettings()
: mSDAChannel(UNDEFINED_CHANNEL)
{
// init the interface
mSDAChannelInterface.SetTitleAndTooltip(CHANNEL_NAME, "Single Wire Interface SDA");
mSDAChannelInterface.SetChannel(mSDAChannel);
mDecodeLevelInterface.SetTitleAndTooltip("Decode level", "Level of the communication to decode");
mDecodeLevelInterface.AddNumber(DL_Tokens, "Tokens", "Decode only the level of tokens");
mDecodeLevelInterface.AddNumber(DL_Bytes, "Bytes", "Group the tokens into bytes");
mDecodeLevelInterface.AddNumber(DL_Packets, "Packets", "Decode the packet contents");
// set default
mDecodeLevelInterface.SetNumber(DL_Packets);
// add the interface
AddInterface(&mSDAChannelInterface);
AddInterface(&mDecodeLevelInterface);
// describe export
AddExportOption(0, "Export as text file");
AddExportExtension(0, "text", "txt");
ClearChannels();
AddChannel(mSDAChannel, CHANNEL_NAME, false);
}
IRAnalyzerSettings::IRAnalyzerSettings()
: mInputChannel( UNDEFINED_CHANNEL ),
mFrequency( 17777 ),
mSignal (NEC_SIG)
{
mInputChannelInterface.reset( new AnalyzerSettingInterfaceChannel() );
mInputChannelInterface->SetTitleAndTooltip( "Input", "Standard InfraRed" );
mInputChannelInterface->SetChannel( mInputChannel );
mFrenquencyInterface.reset( new AnalyzerSettingInterfaceInteger() );
mFrenquencyInterface->SetTitleAndTooltip( "Frequency (Hz)", "Specify the frequency used." );
mFrenquencyInterface->SetMax( 6000000 );
mFrenquencyInterface->SetMin( 1 );
mFrenquencyInterface->SetInteger( mFrequency );
mSignalInterface.reset( new AnalyzerSettingInterfaceNumberList() );
mSignalInterface->SetTitleAndTooltip( "Signal", "Type of signal" );
mSignalInterface->AddNumber( NEC_SIG, "NEC (32 bits)", "");
mSignalInterface->SetNumber( mSignal );
AddInterface( mInputChannelInterface.get() );
AddInterface( mFrenquencyInterface.get() );
AddInterface( mSignalInterface.get() );
AddExportOption( 0, "Export as text/csv file" );
AddExportExtension( 0, "text", "txt" );
AddExportExtension( 0, "csv", "csv" );
ClearChannels();
AddChannel( mInputChannel, "Infrared", false );
}
bool PS2KeyboardAnalyzerSettings::SetSettingsFromInterfaces()
{
mClockChannel = mClockChannelInterface->GetChannel();
mDataChannel = mDataChannelInterface->GetChannel();
mDeviceType = mDeviceTypeInterface->GetNumber();
ClearChannels();
Channel ArrayOfChannels [2];
ArrayOfChannels[0] = mClockChannel;
ArrayOfChannels[1] = mDataChannel;
bool IsInvalidConfig = AnalyzerHelpers::DoChannelsOverlap(ArrayOfChannels,2);
if(IsInvalidConfig)
{
SetErrorText( "Clock and Data must be unique channels!" );
return false;
}
else
{
AddChannel( mClockChannel, "PS/2 - Clock", true );
AddChannel( mDataChannel, "PS/2 - Data", true );
return true;
}
return true;
}
PS2KeyboardAnalyzerSettings::PS2KeyboardAnalyzerSettings()
: mClockChannel( UNDEFINED_CHANNEL ),
mDataChannel( UNDEFINED_CHANNEL ),
mDeviceType( 0 )
{
mClockChannelInterface.reset( new AnalyzerSettingInterfaceChannel() );
mClockChannelInterface->SetTitleAndTooltip( "Clock", "PS/2 - Clock" );
mClockChannelInterface->SetChannel( mClockChannel );
mDataChannelInterface.reset( new AnalyzerSettingInterfaceChannel() );
mDataChannelInterface->SetTitleAndTooltip( "Data", "PS/2 - Data" );
mDataChannelInterface->SetChannel( mDataChannel );
mDeviceTypeInterface.reset( new AnalyzerSettingInterfaceNumberList() );
mDeviceTypeInterface->SetTitleAndTooltip( "Device Type", "Device Type");
mDeviceTypeInterface->AddNumber(0, "Keyboard", "Keyboard");
mDeviceTypeInterface->AddNumber(1, "Mouse (Standard PS/2)", "Mouse (Standard PS/2)");
mDeviceTypeInterface->AddNumber(2, "Mouse (IntelliMouse)", "Mouse (IntelliMouse)");
mDeviceTypeInterface->SetNumber( mDeviceType );
AddInterface( mClockChannelInterface.get() );
AddInterface( mDataChannelInterface.get() );
AddInterface( mDeviceTypeInterface.get() );
AddExportOption( 0, "Export captured keys as text file (Keyboard Only)" );
AddExportExtension( 0, "text", "txt" );
AddExportOption( 1, "Export data as .csv log file" );
AddExportExtension( 1, "csv", "csv" );
ClearChannels();
AddChannel( mClockChannel, "PS/2 - Clock", false );
AddChannel( mDataChannel, "PS/2 - Data", false );
}
PWMAnalyzerSettings::PWMAnalyzerSettings()
: mInputChannel(UNDEFINED_CHANNEL),
mMinChange(3),
mAnalysisType(ANALYSIS_WIDTH)
{
mInputChannelInterface.reset(new AnalyzerSettingInterfaceChannel());
mInputChannelInterface->SetTitleAndTooltip("PWM", "Simple Standard PWM Analyzer");
mInputChannelInterface->SetChannel(mInputChannel);
mAnalysisTypeInterface.reset(new AnalyzerSettingInterfaceNumberList());
mAnalysisTypeInterface->SetTitleAndTooltip("Analysis Type",
"What is important in analyzing this pwm stream?");
mAnalysisTypeInterface->AddNumber(ANALYSIS_WIDTH, "Pulse Width", "The width of high pulses");
mAnalysisTypeInterface->AddNumber(ANALYSIS_DUTY, "Duty Cycle", "The duty cycle between high and low");
mAnalysisTypeInterface->SetNumber(mAnalysisType);
mMinChangeInterface.reset(new AnalyzerSettingInterfaceInteger());
mMinChangeInterface->SetTitleAndTooltip("Min Change(μS or %)",
"The minimum amount of value change before recording a frame.");
mMinChangeInterface->SetMax(10000);
mMinChangeInterface->SetMin(0);
mMinChangeInterface->SetInteger(mMinChange);
AddInterface(mInputChannelInterface.get());
AddInterface(mMinChangeInterface.get());
AddInterface(mAnalysisTypeInterface.get());
AddExportOption(0, "Export as csv file");
AddExportExtension(0, "csv", "csv");
ClearChannels();
AddChannel(mInputChannel, "PWM", false);
}
bool USBAnalyzerSettings::SetSettingsFromInterfaces()
{
if (mDPChannelInterface.GetChannel() == UNDEFINED_CHANNEL)
{
SetErrorText("Please select an input for the D+ channel.");
return false;
}
if (mDMChannelInterface.GetChannel() == UNDEFINED_CHANNEL)
{
SetErrorText("Please select an input for the D- channel.");
return false;
}
mDPChannel = mDPChannelInterface.GetChannel();
mDMChannel = mDMChannelInterface.GetChannel();
mSpeed = USBSpeed(int(mSpeedInterface.GetNumber()));
mDecodeLevel = USBDecodeLevel(int(mDecodeLevelInterface.GetNumber()));
if (mDMChannel == mDPChannel)
{
SetErrorText("Please select different inputs for the D- and D+ channels.");
return false;
}
ClearChannels();
AddChannel(mDPChannel, "D+", true);
AddChannel(mDMChannel, "D-", true);
return true;
}
void ManchesterAnalyzerSettings::LoadSettings( const char* settings )
{
SimpleArchive text_archive;
text_archive.SetString( settings );
const char* name_string; //the first thing in the archive is the name of the protocol analyzer that the data belongs to.
text_archive >> &name_string;
if( strcmp( name_string, "SaleaeManchesterAnalyzer" ) != 0 )
AnalyzerHelpers::Assert( "SaleaeManchesterAnalyzer: Provided with a settings string that doesn't belong to us;" );
text_archive >> mInputChannel;
text_archive >> *(U32*)&mMode;
text_archive >> mBitRate;
text_archive >> mInverted;
text_archive >> mBitsPerTransfer;
text_archive >> *(U32*)&mShiftOrder;
text_archive >> mBitsToIgnore;
ManchesterTolerance tolerance;
if( text_archive >> *(U32*)&tolerance )
mTolerance = tolerance;
ClearChannels();
AddChannel( mInputChannel, "Manchester", true );
UpdateInterfacesFromSettings();
}
SDMMCAnalyzerSettings::SDMMCAnalyzerSettings()
: mClockChannel(UNDEFINED_CHANNEL),
mCommandChannel(UNDEFINED_CHANNEL),
mProtocol(PROTOCOL_MMC),
mSampleEdge(SAMPLE_EDGE_RISING)
{
mClockChannelInterface.reset(new AnalyzerSettingInterfaceChannel());
mClockChannelInterface->SetTitleAndTooltip("Clock", "Clock (CLK)");
mClockChannelInterface->SetChannel(mClockChannel);
mCommandChannelInterface.reset(new AnalyzerSettingInterfaceChannel());
mCommandChannelInterface->SetTitleAndTooltip("Command", "Command (CMD)");
mCommandChannelInterface->SetChannel(mCommandChannel);
mProtocolInterface.reset(new AnalyzerSettingInterfaceNumberList());
mProtocolInterface->SetTitleAndTooltip("Protocol", "Protocol");
mProtocolInterface->AddNumber(PROTOCOL_MMC, "MMC", "MMC protocol");
mProtocolInterface->AddNumber(PROTOCOL_SD, "SD", "SD protocol");
mSampleEdgeInterface.reset(new AnalyzerSettingInterfaceNumberList());
mSampleEdgeInterface->SetTitleAndTooltip("Sample edge", "Clock sampling edge");
mSampleEdgeInterface->AddNumber(SAMPLE_EDGE_RISING, "Rising", "Sample on rising edge");
mSampleEdgeInterface->AddNumber(SAMPLE_EDGE_FALLING, "Falling", "Sample on falling edge");
AddInterface(mClockChannelInterface.get());
AddInterface(mCommandChannelInterface.get());
AddInterface(mProtocolInterface.get());
AddInterface(mSampleEdgeInterface.get());
ClearChannels();
AddChannel(mClockChannel, "Clock", false);
AddChannel(mCommandChannel, "Command", false);
}
SDIOAnalyzerSettings::SDIOAnalyzerSettings()
: mClockChannel( UNDEFINED_CHANNEL ),
mCmdChannel( UNDEFINED_CHANNEL ),
mDAT0Channel( UNDEFINED_CHANNEL ),
mDAT1Channel( UNDEFINED_CHANNEL ),
mDAT2Channel( UNDEFINED_CHANNEL ),
mDAT3Channel( UNDEFINED_CHANNEL )
{
mClockChannelInterface.reset( new AnalyzerSettingInterfaceChannel() );
mCmdChannelInterface.reset( new AnalyzerSettingInterfaceChannel() );
mDAT0ChannelInterface.reset( new AnalyzerSettingInterfaceChannel() );
mDAT1ChannelInterface.reset( new AnalyzerSettingInterfaceChannel() );
mDAT2ChannelInterface.reset( new AnalyzerSettingInterfaceChannel() );
mDAT3ChannelInterface.reset( new AnalyzerSettingInterfaceChannel() );
mClockChannelInterface->SetTitleAndTooltip( "Clock", "Standard SDIO" );
mCmdChannelInterface->SetTitleAndTooltip( "Command", "Standard SDIO" );
mDAT0ChannelInterface->SetTitleAndTooltip( "DAT0", "Standard SDIO" );
mDAT1ChannelInterface->SetTitleAndTooltip( "DAT1", "Standard SDIO" );
mDAT2ChannelInterface->SetTitleAndTooltip( "DAT2", "Standard SDIO" );
mDAT3ChannelInterface->SetTitleAndTooltip( "DAT3", "Standard SDIO" );
mClockChannelInterface->SetChannel( mClockChannel );
mCmdChannelInterface->SetChannel( mCmdChannel );
mDAT0ChannelInterface->SetChannel( mDAT0Channel );
mDAT1ChannelInterface->SetChannel( mDAT1Channel );
mDAT2ChannelInterface->SetChannel( mDAT2Channel );
mDAT3ChannelInterface->SetChannel( mDAT3Channel );
mClockChannelInterface->SetSelectionOfNoneIsAllowed( false );
mCmdChannelInterface->SetSelectionOfNoneIsAllowed( false );
mDAT0ChannelInterface->SetSelectionOfNoneIsAllowed( false );
mDAT1ChannelInterface->SetSelectionOfNoneIsAllowed( true );
mDAT2ChannelInterface->SetSelectionOfNoneIsAllowed( true );
mDAT3ChannelInterface->SetSelectionOfNoneIsAllowed( true );
AddInterface( mClockChannelInterface.get() );
AddInterface( mCmdChannelInterface.get() );
AddInterface( mDAT0ChannelInterface.get() );
AddInterface( mDAT1ChannelInterface.get() );
AddInterface( mDAT2ChannelInterface.get() );
AddInterface( mDAT3ChannelInterface.get() );
AddExportOption( 0, "Export as text/csv file" );
AddExportExtension( 0, "text", "txt" );
AddExportExtension( 0, "csv", "csv" );
ClearChannels();
// AddChannel( mInputChannel, "Serial", false );
AddChannel( mClockChannel, "Clock", false );
AddChannel( mCmdChannel, "Command", false );
AddChannel( mDAT0Channel, "DAT0", false );
AddChannel( mDAT1Channel, "DAT1", false );
AddChannel( mDAT2Channel, "DAT2", false );
AddChannel( mDAT3Channel, "DAT3", false );
}
bool HdmiCecAnalyzerSettings::SetSettingsFromInterfaces()
{
mCecChannel = mCecChannelInterface->GetChannel();
ClearChannels();
AddChannel( mCecChannel, HdmiCec::GetProtocolName(), true );
return true;
}
bool SimpleSerialAnalyzerSettings::SetSettingsFromInterfaces()
{
mInputChannel = mInputChannelInterface->GetChannel();
mBitRate = mBitRateInterface->GetInteger();
ClearChannels();
AddChannel( mInputChannel, "Simple Serial", true );
return true;
}
bool SPDIFAnalyzerSettings::SetSettingsFromInterfaces()
{
mInputChannel = mInputChannelInterface->GetChannel();
mSampleRate = mSampleRateInterface->GetInteger();
ClearChannels();
AddChannel( mInputChannel, "SPDIF", true );
return true;
}
bool ISO14443AnalyzerSettings::SetSettingsFromInterfaces()
{
mInputChannel = mInputChannelInterface->GetChannel();
mBitRate = mBitRateInterface->GetInteger();
ClearChannels();
AddChannel( mInputChannel, "ISO14443", true );
return true;
}
LD110AnalyzerSettings::LD110AnalyzerSettings() : m_oGlobalClockChannel(UNDEFINED_CHANNEL)
{
for(int nIndex = 0; nIndex < m_nBCDAndDigitChannelCount; nIndex++)
{
m_oBCDChannelInterfaceVector[nIndex].reset(new AnalyzerSettingInterfaceChannel());
m_oBCDChannelVector.push_back(Channel(UNDEFINED_CHANNEL));
m_oDigitChannelInterfaceVector[nIndex].reset(new AnalyzerSettingInterfaceChannel());
m_oDigitChannelVector.push_back(Channel(UNDEFINED_CHANNEL));
}
m_oGlobalClockChannelInterface.reset(new AnalyzerSettingInterfaceChannel());
for(int nIndex = 0; nIndex < m_nBCDAndDigitChannelCount; nIndex++)
{
m_oTitle.str("BCD Bit ");
m_oTitle << (nIndex + 1);
m_oTooltip.str("BCD Bit ");
m_oTooltip << nIndex + 1 << " (Pin " << 16 - nIndex << ")";
m_oBCDChannelInterfaceVector[nIndex]->SetTitleAndTooltip(m_oTitle.str().c_str(), m_oTooltip.str().c_str());
m_oBCDChannelInterfaceVector[nIndex]->SetChannel(m_oBCDChannelVector[nIndex]);
AddInterface(m_oBCDChannelInterfaceVector[nIndex].get());
}
for(int nIndex = 0; nIndex < m_nBCDAndDigitChannelCount; nIndex++)
{
m_oTitle.str("Digit ");
m_oTitle << nIndex + 1 << " clock";
m_oTooltip.str("The clock for digit ");
m_oTooltip << nIndex + 1 << " (Pin " << 1 + nIndex << ")";
m_oDigitChannelInterfaceVector[nIndex]->SetTitleAndTooltip(m_oTitle.str().c_str(), m_oTooltip.str().c_str());
m_oDigitChannelInterfaceVector[nIndex]->SetChannel(m_oDigitChannelVector[nIndex]);
AddInterface(m_oDigitChannelInterfaceVector[nIndex].get());
}
m_oGlobalClockChannelInterface.reset(new AnalyzerSettingInterfaceChannel());
m_oGlobalClockChannelInterface->SetTitleAndTooltip("Global clock", "The clock for LD110 IC");
m_oGlobalClockChannelInterface->SetChannel(m_oGlobalClockChannel);
AddInterface(m_oGlobalClockChannelInterface.get());
AddExportOption( 0, "Export as text/csv file" );
AddExportExtension( 0, "text", "txt" );
AddExportExtension( 0, "csv", "csv" );
ClearChannels();
AddChannels();
}
bool IRAnalyzerSettings::SetSettingsFromInterfaces()
{
mInputChannel = mInputChannelInterface->GetChannel();
mFrequency = mFrenquencyInterface->GetInteger();
mSignal = (IRSignal) U32( mSignalInterface->GetNumber() );
ClearChannels();
AddChannel( mInputChannel, "Infrared", true );
return true;
}
bool PWMAnalyzerSettings::SetSettingsFromInterfaces()
{
mInputChannel = mInputChannelInterface->GetChannel();
mMinChange = mMinChangeInterface->GetInteger();
mAnalysisType = mAnalysisTypeInterface->GetNumber();
ClearChannels();
AddChannel(mInputChannel, "PWM Analyzer", true);
return true;
}
bool Xlink2WAnalyzerSettings::SetSettingsFromInterfaces()
{
chanW0 = chanW0Interface->GetChannel();
chanW1 = chanW1Interface->GetChannel();
ClearChannels();
AddChannel( chanW0, "XLINK Wire 0", true );
AddChannel( chanW1, "XLINK Wire 1", true );
return true;
}
bool SWDAnalyzerSettings::SetSettingsFromInterfaces()
{
mSWDIOChannel = mSWDIOChannelInterface->GetChannel();
mSWCLKChannel = mSWCLKChannelInterface->GetChannel();
ClearChannels();
AddChannel( mSWDIOChannel, "SWDIO", true );
AddChannel( mSWCLKChannel, "SWCLK", true );
return true;
}
void HdmiCecAnalyzerSettings::LoadSettings( const char* settings )
{
SimpleArchive text_archive;
text_archive.SetString( settings );
text_archive >> mCecChannel;
ClearChannels();
AddChannel( mCecChannel, HdmiCec::GetProtocolName(), true );
UpdateInterfacesFromSettings();
}
bool QuadratureAnalyserAnalyzerSettings::SetSettingsFromInterfaces()
{
mInputChannelA = mInputChannelAInterface->GetChannel();
mInputChannelB = mInputChannelBInterface->GetChannel();
ticksPerRotation = mTicksPerRotationInterface->GetInteger();
ticksPerFrame = mTicksPerFrameInterface->GetInteger();
ClearChannels();
AddChannel( mInputChannelA, "Quadrature A", true);
AddChannel( mInputChannelB, "Quadrature B", true);
return true;
}
void ISO14443AnalyzerSettings::LoadSettings( const char* settings )
{
SimpleArchive text_archive;
text_archive.SetString( settings );
text_archive >> mInputChannel;
text_archive >> mBitRate;
ClearChannels();
AddChannel( mInputChannel, "ISO14443", true );
UpdateInterfacesFromSettings();
}
void SWDAnalyzerSettings::LoadSettings( const char* settings )
{
SimpleArchive text_archive;
text_archive.SetString( settings );
text_archive >> mSWDIOChannel;
text_archive >> mSWCLKChannel;
ClearChannels();
AddChannel( mSWDIOChannel, "SWDIO", true );
AddChannel( mSWCLKChannel, "SWCLK", true );
UpdateInterfacesFromSettings();
}
void MDIOAnalyzerSettings::LoadSettings( const char* settings )
{
SimpleArchive text_archive;
text_archive.SetString( settings );
text_archive >> mMdioChannel;
text_archive >> mMdcChannel;
ClearChannels();
AddChannel( mMdioChannel, "MDIO", true );
AddChannel( mMdcChannel, "MDC", true );
UpdateInterfacesFromSettings();
}
void Xlink2WAnalyzerSettings::LoadSettings( const char* settings )
{
SimpleArchive text_archive;
text_archive.SetString( settings );
text_archive >> chanW0;
text_archive >> chanW1;
ClearChannels();
AddChannel( chanW0, "XLINK Wire 0", true );
AddChannel( chanW1, "XLINK Wire 1", true );
UpdateInterfacesFromSettings();
}
void PWMAnalyzerSettings::LoadSettings(const char *settings)
{
SimpleArchive text_archive;
text_archive.SetString(settings);
text_archive >> mInputChannel;
text_archive >> mMinChange;
text_archive >> mAnalysisType;
ClearChannels();
AddChannel(mInputChannel, "Simple PWM Analyzer", true);
UpdateInterfacesFromSettings();
}
bool ManchesterAnalyzerSettings::SetSettingsFromInterfaces()
{
mInputChannel = mInputChannelInterface->GetChannel();
mMode = ManchesterMode( U32( mModeInterface->GetNumber() ) );
mBitRate = mBitRateInterface->GetInteger();
mInverted = bool( U32( mInvertedInterface->GetNumber() ) );
mBitsPerTransfer = U32( mBitsPerTransferInterface->GetNumber() );
mShiftOrder = AnalyzerEnums::ShiftOrder( U32( mShiftOrderInterface->GetNumber() ) );
mBitsToIgnore = mNumBitsIgnoreInterface->GetInteger();
mTolerance = ManchesterTolerance( U32( mToleranceInterface->GetNumber() ) );
ClearChannels();
AddChannel( mInputChannel, "Manchester", true );
return true;
}
void PS2KeyboardAnalyzerSettings::LoadSettings( const char* settings )
{
SimpleArchive text_archive;
text_archive.SetString( settings );
text_archive >> mClockChannel;
text_archive >> mDataChannel;
text_archive >> mDeviceType;
ClearChannels();
AddChannel( mClockChannel, "PS/2 - Clock", true );
AddChannel( mDataChannel, "PS/2 - Data", true );
UpdateInterfacesFromSettings();
}
