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(); }
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); }
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; }
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 ); }
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; }
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; }
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 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 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 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(); }
void LD110AnalyzerSettings::AddChannels() { for(int nIndex = 0; nIndex < m_nBCDAndDigitChannelCount; nIndex++) { m_oTitle.str("Digit "); m_oTitle << nIndex + 1 << " clock"; AddChannel(m_oDigitChannelVector[nIndex], m_oTitle.str().c_str(), true); m_oTitle.str("Digit "); m_oTitle << nIndex + 1 << " clock"; AddChannel(m_oDigitChannelVector[nIndex], m_oTitle.str().c_str(), true); } AddChannel(m_oGlobalClockChannel, "Global IC clock", true); }
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 ); }
IOLoop::IOLoop(UINT id, IChannelListener* listener, Channel** channel) : m_id(id), m_shouldRun(false), m_threadHandle(NULL) { Channel* ioChannel; ChannelQueue::CreateQueuePair(id + 1, listener, this, channel, &ioChannel); AddChannel(ioChannel); }
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); }
static void iauth_loc_conf_read(void) { dict_t node; const char *str1; const char *str2; node = conf_get_data("modules/blacklist", RECDB_OBJECT); if (node == NULL) return; str1 = database_get_data(node, "debug_bot", RECDB_QSTRING); if (str1) conf.debug_bot = GetUserH(str1); str1 = database_get_data(node, "debug_channel", RECDB_QSTRING); if (conf.debug_bot && str1) { str2 = database_get_data(node, "debug_channel_modes", RECDB_QSTRING); if (!str2) str2 = "+tinms"; conf.debug_channel = AddChannel(str1, now, str2, NULL); AddChannelUser(conf.debug_bot, conf.debug_channel)->modes |= MODE_CHANOP; } else { conf.debug_channel = NULL; } }
void TestPreset::AddChannelRange(int start, int end) { for (int i = start; i <= end; i++) { AddChannel(i); } }
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(); }
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); }
static void track_conf_read(void) { dict_t node; char *str, *modes; node = conf_get_data("modules/track", RECDB_OBJECT); if (!node) return; str = database_get_data(node, "snomask", RECDB_QSTRING); if (!str) track_cfg.snomask = TRACK_NICK|TRACK_KICK|TRACK_JOIN|TRACK_PART|TRACK_CHANMODE|TRACK_NEW|TRACK_DEL|TRACK_AUTH; else parse_track_conf(str); str = database_get_data(node, "channel", RECDB_QSTRING); modes = database_get_data(node, "channel_modes", RECDB_QSTRING); if (!str) return; // XXX - dont do addchannel if the channel is being shared with // another module: track_cfg.channel = AddChannel(str, now, (modes ? modes : "+sntOm"), NULL, NULL); if (!track_cfg.channel) return; str = database_get_data(node, "show_bursts", RECDB_QSTRING); track_cfg.show_bursts = str ? enabled_string(str) : 0; track_cfg.enabled = 1; if (finalized) track_finalize(); }
bool CChoreoActor::RestoreFromBuffer( CUtlBuffer& buf, CChoreoScene *pScene ) { char sz[ 256 ]; buf.GetString( sz, sizeof( sz ) ); SetName( sz ); int i; int c = buf.GetShort(); for ( i = 0; i < c; i++ ) { CChoreoChannel *channel = pScene->AllocChannel(); Assert( channel ); if ( channel->RestoreFromBuffer( buf, pScene, this ) ) { AddChannel( channel ); channel->SetActor( this ); continue; } return false; } SetActive( buf.GetChar() == 1 ? true : false ); return true; }
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(); }
void CImageChannelAdd::Init(EChannel eChannel, EPrimitiveTypes eType, int iGroup) { maiChannels.Init(1); meType = eType; miGroup = iGroup; AddChannel(eChannel); }
bool DTVConfParser::ParseConfOFDM(const QStringList &tokens) { DTVChannelInfo chan; DTVMultiplex mux; QStringList::const_iterator it = tokens.begin(); PARSE_SKIP(unknown); PARSE_UINT(mux.frequency); PARSE_CONF(mux.inversion); PARSE_CONF(mux.bandwidth); PARSE_CONF(mux.hp_code_rate); PARSE_CONF(mux.lp_code_rate); PARSE_CONF(mux.modulation); PARSE_CONF(mux.trans_mode); PARSE_CONF(mux.guard_interval); PARSE_CONF(mux.hierarchy); PARSE_SKIP(unknown); PARSE_SKIP(unknown); PARSE_UINT(chan.serviceid); AddChannel(mux, chan); return true; }
void QuadratureAnalyserAnalyzerSettings::LoadSettings( const char* settings ) { SimpleArchive text_archive; text_archive.SetString( settings ); text_archive >> mInputChannelA; text_archive >> mInputChannelB; text_archive >> ticksPerRotation; text_archive >> ticksPerFrame; ClearChannels(); AddChannel( mInputChannelA, "Quadrature A", true); AddChannel( mInputChannelB, "Quadrature B", true); UpdateInterfacesFromSettings(); }
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 ); }
bool MDIOAnalyzerSettings::SetSettingsFromInterfaces() { if( mMdioChannelInterface->GetChannel() == mMdcChannelInterface->GetChannel() ) { SetErrorText( "MDIO and MDC can't be assigned to the same input." ); return false; } mMdioChannel = mMdioChannelInterface->GetChannel(); mMdcChannel = mMdcChannelInterface->GetChannel(); ClearChannels(); AddChannel( mMdioChannel, "MDIO", true ); AddChannel( mMdcChannel, "MDC", true ); return true; }
void DABlinGTK::AddChannels() { if(options.displayed_channels.empty()) { // add all channels for(dab_channels_t::const_iterator it = dab_channels.cbegin(); it != dab_channels.cend(); it++) AddChannel(it); } else { // add specific channels std::stringstream ss(options.displayed_channels); std::string ch; while(std::getline(ss, ch, ',')) { dab_channels_t::const_iterator it = dab_channels.find(ch); if(it != dab_channels.end()) AddChannel(it); } } }
bool HdmiCecAnalyzerSettings::SetSettingsFromInterfaces() { mCecChannel = mCecChannelInterface->GetChannel(); ClearChannels(); AddChannel( mCecChannel, HdmiCec::GetProtocolName(), true ); return true; }