void MDIOAnalyzerResults::GenBubbleText(U64 frame_index, DisplayBase display_base, bool tabular) 
{
	ClearResultStrings();
	Frame frame = GetFrame( frame_index );
    
    switch( frame.mType ) 
	{
		case MDIO_C22_START: 			GenStartString(frame, "22", tabular); break;
		case MDIO_C45_START: 			GenStartString(frame, "45", tabular); break;
		case MDIO_OP_W: 				GenOpString(frame, "W", "WR", "Write", tabular); break;
		case MDIO_OP_R: 				GenOpString(frame, "R", "RD", "Read", tabular); break;
		case MDIO_C45_OP_ADDR: 			GenOpString(frame, "A", "AD", "Address", tabular); break;
		case MDIO_C45_OP_READ_INC_ADDR:	GenOpString(frame, "R+A", "RD +AD", "Read-Increment-Address", tabular); break;
		case MDIO_PHYADDR: 				GenPhyAddrString(frame, display_base, tabular); break;
		case MDIO_C22_REGADDR: 			GenC22RegAddrString(frame, display_base, tabular); break;
		case MDIO_C45_DEVTYPE_RESERVED: GenC45DevTypeString(frame, display_base, "Reserved", tabular); break;
		case MDIO_C45_DEVTYPE_PMD_PMA: 	GenC45DevTypeString(frame, display_base, "PMD/PMA", tabular); break;
		case MDIO_C45_DEVTYPE_WIS: 		GenC45DevTypeString(frame, display_base, "WIS", tabular); break;
		case MDIO_C45_DEVTYPE_PCS: 		GenC45DevTypeString(frame, display_base, "PCS", tabular); break;
		case MDIO_C45_DEVTYPE_PHY_XS: 	GenC45DevTypeString(frame, display_base, "PHY XS", tabular); break;
		case MDIO_C45_DEVTYPE_DTE_XS: 	GenC45DevTypeString(frame, display_base, "DTE XS", tabular); break;
		case MDIO_C45_DEVTYPE_OTHER: 	GenC45DevTypeString(frame, display_base, "Other", tabular); break;
		case MDIO_TA: 					GenTAString(frame, display_base, tabular); break;
		case MDIO_C22_DATA: 			GenC22DataString(frame, display_base, tabular); break;
		case MDIO_C45_ADDR: 			GenC45AddrDataString(frame, display_base, "A", "ADDR", "Address", tabular); break;
		case MDIO_C45_DATA: 			GenC45AddrDataString(frame, display_base, "D", "DATA", "Data", tabular); break;
		case MDIO_UNKNOWN:				GenUnknownString(tabular); break;
    }
}
void SDIOAnalyzerResults::GenerateBubbleText( U64 frame_index, Channel& channel, DisplayBase display_base )
{
	ClearResultStrings();
	Frame frame = GetFrame( frame_index );

	char number_str1[128];
	char number_str2[128];
	if (frame.mType == SDIOAnalyzer::FRAME_DIR){
		if (frame.mData1){
			AddResultString("H");
			AddResultString("Host");
			AddResultString("DIR: Host");
		}else{
			AddResultString("S");
			AddResultString("Slave");
			AddResultString("DIR: Slave");
		}
	}else if (frame.mType == SDIOAnalyzer::FRAME_CMD){
		AnalyzerHelpers::GetNumberString( frame.mData1, Decimal, 6, number_str1, 128 );
		AddResultString("CMD ", number_str1);
	}else if (frame.mType == SDIOAnalyzer::FRAME_ARG){
		AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 32, number_str1, 128 );
		AddResultString("ARG ", number_str1);
	}else if (frame.mType == SDIOAnalyzer::FRAME_LONG_ARG){
		AnalyzerHelpers::GetNumberString (frame.mData1, display_base, 64, number_str1, 128);
		AnalyzerHelpers::GetNumberString (frame.mData2, display_base, 64, number_str2, 128);
		AddResultString("LONG: ", number_str1, number_str2);

	}else if (frame.mType == SDIOAnalyzer::FRAME_CRC){
		AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 7, number_str1, 128 );
		AddResultString("CRC ", number_str1);
	}
}
void NeopixelAnalyzerResults::GenerateFrameTabularText( U64 frame_index, DisplayBase display_base )
{
	Frame frame = GetFrame( frame_index );
	ClearResultStrings();

	char number_str[128];
	sprintf(number_str, "%02X", frame.mData1);
	AddResultString( number_str );
}
void NeopixelAnalyzerResults::GenerateBubbleText( U64 frame_index, Channel& channel, DisplayBase display_base )
{
	ClearResultStrings();
	Frame frame = GetFrame( frame_index );

	char number_str[128];
	sprintf(number_str, "%02X", frame.mData1);
	AddResultString( number_str );
}
void ManchesterAnalyzerResults::GenerateBubbleText( U64 frame_index, Channel& /*channel*/, DisplayBase display_base )
{
	Frame frame = GetFrame( frame_index );
	ClearResultStrings();

	char number_str[128];
	AnalyzerHelpers::GetNumberString( frame.mData1, display_base, mSettings->mBitsPerTransfer, number_str, 128 );
	AddResultString( number_str );
}
Exemplo n.º 6
0
void J2716AnalyzerResults::GenerateFrameTabularText( U64 frame_index, DisplayBase display_base )
{
	Frame frame = GetFrame( frame_index );
	ClearResultStrings();

	char number_str[128];
	AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 8, number_str, 128 );
	AddResultString( number_str );
}
void N64AnalyzerResults::GenerateBubbleText( U64 frame_index, Channel& channel, DisplayBase display_base )
{
	ClearResultStrings();
	Frame frame = GetFrame( frame_index );

	char number_str[128];
	AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 8, number_str, 128 );
	AddResultString( number_str );
}
Exemplo n.º 8
0
void MidiAnalyzerResults::GenerateBubbleText( U64 frame_index, Channel& channel, DisplayBase display_base )
{
	ClearResultStrings();
	Frame frame = GetFrame( frame_index );
	
	enum MidiFrameType FrameType;
	union stash stash1;
	FrameType = (enum MidiFrameType) frame.mType;
	stash1.mData2 = frame.mData2;
	
	localDisplay_base = display_base;
	localFrame = frame;
	localFrame_index = frame_index;
	
	
	results( FrameType, stash1 );
}
void Pn5180AnalyzerResults::GenerateBubbleText( U64 frame_index, Channel& channel, DisplayBase display_base )  //unrefereced vars commented out to remove warnings.
{
	ClearResultStrings();
	Frame frame = GetFrame( frame_index );
	if(  frame.mFlags & Pn5180_INSTRUCTION_FLAG )
	{
		if ( channel == mSettings->mEnableChannel )
		{
			if (frame.mData1 >= NUM_INSTRUCTIONS)
			{
				char number_str[128];
				AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 8, number_str, 128 );
				AddResultString( number_str );
				AddResultString( "Unknown Instruction" );
			}
			else
			{
				AddResultString( Pn5180InstructionCodes[frame.mData1] );
			}
		}
	}
	else
	{
		if( ( frame.mFlags & Pn5180_ERROR_FLAG ) == 0 )
		{
			if( channel == mSettings->mMosiChannel )
			{
				char number_str[128];
				AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 8, number_str, 128 );
				AddResultString( number_str );

			}else
			{
				char number_str[128];
				AnalyzerHelpers::GetNumberString( frame.mData2, display_base, 8, number_str, 128 );
				AddResultString( number_str );
			}
		}else
		{
				AddResultString( "Error" );
				AddResultString( "Settings mismatch" );
				AddResultString( "The initial (idle) state of the CLK line does not match the settings." );
		}
	}
}
Exemplo n.º 10
0
void SDIOAnalyzerResults::GenerateBubbleText( U64 frame_index, Channel& channel, DisplayBase display_base )
{
	ClearResultStrings();
	Frame frame = GetFrame( frame_index );

    // if this is command data
    if (frame.mType == FRAME_TYPE_CMD_DATA)
    {
        SdioCmd *tmp = SdioCmd::CreateSdioCmd(frame.mData1);
        string *s = tmp->getShortString();
		AddResultString( s->c_str() );
        delete s;
    }
    // else, this is data line data, should be partitioned into bytes
    else
    {
        char number_str[128] = {0};
        sprintf(number_str, "0x%02X", frame.mData1);
        AddResultString( number_str );
    }
}
void PJONAnalyzerResults::GenerateBubbleText( U64 frame_index, Channel& channel, DisplayBase display_base )
{
	ClearResultStrings();
	Frame frame = GetFrame( frame_index );
 
	char number_str[128];
    switch (frame.mType) {
        case Sync: {
            char* str = PJONPacketState::asDisplayString(frame.mFlags);
            AddResultString("s");
            AddResultString("Sync");
            AddResultString("Sync ", str);
            break;
        }
            
        case Data: {
            UILabel label = GetAckNackLabels(frame_index);
            AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 8, number_str, 128 );
            AddResultString(label.tiny.c_str());
            AddResultString(label.medium.c_str());
            AddResultString("Data ", label.full.c_str(), " ", number_str);
            break;
        }
            
        case Error: {
            AddResultString("e");
            AddResultString("Error");
            break;
        }
            
        default: {
           	AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 8, number_str, 128 );
            AddResultString( number_str );
            break;
        }
    }

}
void RC663AnalyzerResults::GenerateBubbleText( U64 frame_index, Channel& channel, DisplayBase display_base )  //unrefereced vars commented out to remove warnings.
{
	ClearResultStrings();

	Frame frame = GetFrame( frame_index );

	if( frame.mFlags & RC663_REGISTER_FLAG )
	{
		if ( channel == mSettings->mEnableChannel )
		{
			U64 regDef = frame.mData1 >> 1;

			if (regDef >= NUM_REGISTERS)
			{
				char number_str[128];
				AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 8, number_str, 128 );
				AddResultString( number_str );
				AddResultString( "Unknown Instruction" );
			}
			else
			{
            if(frame.mData1 & 0x01)
            {
   				AddResultString( "read" );
               AddResultString( "read ", RC663Registers[regDef].short_text );
               AddResultString( "read ", RC663Registers[regDef].long_text);
            }
            else
            {
   				AddResultString( "write" );
               AddResultString( "write ", RC663Registers[regDef].short_text );
               AddResultString( "write ", RC663Registers[regDef].long_text );
            }
			}
		}
	}
Exemplo n.º 13
0
void UnioAnalyzerResults::GenerateTransactionTabularText( U64 /*transaction_id*/, DisplayBase /*display_base*/ )  //unrefereced vars commented out to remove warnings.
{
	ClearResultStrings();
	AddResultString( "not supported" );
}
Exemplo n.º 14
0
void UnioAnalyzerResults::GenerateBubbleText( U64 frame_index, Channel& /*channel*/, DisplayBase display_base )  //unrefereced vars commented out to remove warnings.
{
	//we only need to pay attention to 'channel' if we're making bubbles for more than one channel (as set by AddChannelBubblesWillAppearOn)
	ClearResultStrings();
	Frame frame = GetFrame( frame_index );

	//enum UnioFrameType { HeaderFrame, AddressFrame8, AddressFrame12, DataFrame, InvalidBit, ErrorMakRequired, ErrorNoSakRequired };
	switch( UnioFrameType( frame.mType ) )
	{
	case HeaderFrame:
		{
			double bit_rate = double( mAnalyzer->GetSampleRate() ) / ( double( frame.mData1 ) * .125 );
			char frequency[256];
			sprintf( frequency, "%.1f kHz", bit_rate * .001 );

			AddResultString( "H" );
			AddResultString( "Header" );
			AddResultString( "Header; ", frequency );
			AddResultString( "Header; ", frequency );
			AddResultString( "Header; Bit-rate: ",  frequency );
		}
		break;
	case AddressFrame8:
	case AddressFrame12:
		{
			char number_str[128];
			if( UnioFrameType( frame.mType ) == AddressFrame8 )
				AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 8, number_str, 128 );
			else
				AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 12, number_str, 128 );

			char master_ack[16];
			if( ( frame.mFlags & MASTER_ACK ) != 0 )
				sprintf( master_ack, "MAK" );
			else
				sprintf( master_ack, "NoMAK" );

			char slave_ack[16];
			if( ( frame.mFlags & SLAVE_ACK ) != 0 )
				sprintf( slave_ack, "SAK" );
			else
				sprintf( slave_ack, "NoSAK" );

			AddResultString( "A" );
			AddResultString( "A: ", number_str );
			AddResultString( "Address: ", number_str );
			AddResultString( "Address: ", number_str, "; ", master_ack, "; ", slave_ack );
		}
		break;
	case DataFrame:
		{
			char number_str[128];
			AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 8, number_str, 128 );

			char master_ack[16];
			if( ( frame.mFlags & MASTER_ACK ) != 0 )
				sprintf( master_ack, "MAK" );
			else
				sprintf( master_ack, "NoMAK" );

			char slave_ack[16];
			if( ( frame.mFlags & SLAVE_ACK ) != 0 )
				sprintf( slave_ack, "SAK" );
			else
				sprintf( slave_ack, "NoSAK" );

			AddResultString( "D" );
			AddResultString( number_str );
			AddResultString( "Data: ", number_str );
			AddResultString( "Data: ", number_str, "; ", master_ack, "; ", slave_ack );
		}
		break;
	case ErrorMakRequired:
		AddResultString( "!" );
		AddResultString( "Error" );
		AddResultString( "Error: MAK is required" );
		break;
	case ErrorNoSakRequired:
		AddResultString( "!" );
		AddResultString( "Error" );
		AddResultString( "Error: NoSAK is required" );
		break;
	case InvalidBit:
		AddResultString( "!" );
		AddResultString( "Error" );
		AddResultString( "Error: Invalid UNIO bit" );
		break;
	default:
		AnalyzerHelpers::Assert( "unexpected" );
		break;
	}

}
Exemplo n.º 15
0
void J2716AnalyzerResults::GenerateBubbleText( U64 frame_index, Channel& channel, DisplayBase display_base )
{
	ClearResultStrings();
	Frame frame = GetFrame( frame_index );
	U8 u8TempCrc = 0;
	char ai8Data1Str[ 64 ];
	char ai8Data2Str[ 64 ];
	char ai8TicksStr[ 16 ];
	char ai8TimeStr[ 16 ];
	U8 u8Ticks = 0;
	const double kdMicro = 1E-6;
	const double kdRoundError = 1E-19;
	double dFramePeriod = double( 0 );

	dFramePeriod = ( double( frame.mEndingSampleInclusive ) - double( frame.mStartingSampleInclusive ) ) / double( mAnalyzer->GetSampleRate( ) ) + kdRoundError;
	u8Ticks = U8( dFramePeriod / double( mSettings->mBitRate*kdMicro ) );

	AnalyzerHelpers::GetNumberString( frame.mData1 , display_base , 2 , &ai8Data1Str[ 0 ] , sizeof( ai8Data1Str ) );
	AnalyzerHelpers::GetNumberString( u8Ticks , Decimal , 2 , &ai8TicksStr[ 0 ] , sizeof( ai8TicksStr ) );

	switch( frame.mType )
	{
		case SENTSync:
		AnalyzerHelpers::GetTimeString( frame.mEndingSampleInclusive , frame.mStartingSampleInclusive , mAnalyzer->GetSampleRate() , &ai8TimeStr[ 0 ] , 9/* x.xxxxxx + '\0'  */ );
		AddResultString( "SYNC " );
		AddResultString( "SYNC Field ~" , ai8TicksStr , " ticks" );
		AddResultString( "SYNC Field ~" , ai8TicksStr , " ticks [" , ai8TimeStr , " s]" );
		break;
		case SENTStatus:
		AddResultString( "STAT " );
		AddResultString( "STATUS " );
		AddResultString( "STATUS " , ai8Data1Str );
		AddResultString( "STATUS " , ai8Data1Str ," ~" , ai8TicksStr , " ticks" );
		break;
		case SENTData:
		AnalyzerHelpers::GetNumberString( frame.mData2 , Decimal , 8 , &ai8Data2Str[ 0 ] , sizeof( ai8Data2Str ) );
		AddResultString( "DATA " );
		AddResultString( "DATA " , ai8Data2Str );
		AddResultString( "DATA " , ai8Data2Str , " [" , ai8Data1Str , "]" );
		break;
		case SENTCrc:
		//u8TempCrc =mAnalyzer
		if( frame.mData1 == frame.mData2 )
		{
			AddResultString( "CRC " );
			AddResultString( "CRC OK" );
			AddResultString( "CRC OK [" , ai8Data1Str , "]" );
		}
		else
		{
			AnalyzerHelpers::GetNumberString( frame.mData2 , display_base , 2 , &ai8Data2Str[ 0 ] , sizeof( ai8Data2Str ) );
			AddResultString( "CRC! " );
			AddResultString( "CRC! Rx[" , ai8Data1Str , "] Calc{" , ai8Data2Str , "}" );
		}
		break;
		case SENTPause:
		AnalyzerHelpers::GetTimeString( frame.mEndingSampleInclusive , frame.mStartingSampleInclusive , mAnalyzer->GetSampleRate() , &ai8TimeStr[ 0 ] , 9/* x.xxxxxx */ );
		AddResultString( "PAUSE " );
		AddResultString( "PAUSE ~" , ai8TicksStr , " ticks" );
		AddResultString( "PAUSE ~" , ai8TicksStr , " ticks [",ai8TimeStr , " s]" );
		break;
		default:
		//frame.mFlags |= DISPLAY_AS_ERROR_FLAG;
		AnalyzerHelpers::GetNumberString( frame.mData2 , Decimal , 8 , &ai8Data2Str[ 0 ] , sizeof( ai8Data2Str ) );
		AnalyzerHelpers::GetTimeString( frame.mEndingSampleInclusive , frame.mStartingSampleInclusive , mAnalyzer->GetSampleRate() , &ai8TimeStr[ 0 ] , 9/* x.xxxxxx */ );
		AddResultString( "?? " );
		AddResultString( "?? " , ai8TicksStr );
		AddResultString( "?? " , ai8TicksStr , " Ticks @ " , ai8TimeStr , " s" );
		break;
	}
}
void Pn5180AnalyzerResults::GeneratePacketTabularText( U64 /*packet_id*/, DisplayBase /*display_base*/ )  //unrefereced vars commented out to remove warnings.
{
	ClearResultStrings();
	AddResultString( "not supported" );
}
Exemplo n.º 17
0
void J2716AnalyzerResults::GeneratePacketTabularText( U64 packet_id, DisplayBase display_base )
{
	ClearResultStrings();
	AddResultString( "not supported" );
}
Exemplo n.º 18
0
void J2716AnalyzerResults::GenerateTransactionTabularText( U64 transaction_id, DisplayBase display_base )
{
	ClearResultStrings();
	AddResultString( "not supported" );
}
Exemplo n.º 19
0
void CanAnalyzerResults::GenerateBubbleText( U64 frame_index, Channel& /*channel*/, DisplayBase display_base )  //unrefereced vars commented out to remove warnings.
{
	//we only need to pay attention to 'channel' if we're making bubbles for more than one channel (as set by AddChannelBubblesWillAppearOn)
	ClearResultStrings();
	Frame frame = GetFrame( frame_index );

	switch( frame.mType )
	{
	case IdentifierField:
	case IdentifierFieldEx:
		{
			char number_str[128];

			if( frame.mType == IdentifierField )
				AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 12, number_str, 128 );
			else
				AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 32, number_str, 128 );

			std::stringstream ss;

			AddResultString( "Id" );

			ss << "Id: " << number_str;
			AddResultString( ss.str().c_str() );
			ss.str("");

            ss << "Identifier: " << number_str;
			AddResultString( ss.str().c_str() );
			ss.str("");

			if( frame.HasFlag( REMOTE_FRAME ) == false )
			{
				if( frame.mType == IdentifierField )
					ss << "Standard CAN Identifier: " << number_str;
				else
					ss << "Extended CAN Identifier: " << number_str;
			}else
			{
				if( frame.mType == IdentifierField )
					ss << "Standard CAN Identifier: " << number_str << " (RTR)";
				else
					ss << "Extended CAN Identifier: " << number_str << " (RTR)";
			}

			AddResultString( ss.str().c_str() );
		}
		break;
	case ControlField:
		{
			char number_str[128];
			AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 4, number_str, 128 );

			std::stringstream ss;
			AddResultString( "Ctrl" );

			ss << "Ctrl: " << number_str;
			AddResultString( ss.str().c_str() );
			ss.str("");

			ss << "Control Field: " << number_str;
			AddResultString( ss.str().c_str() );

			ss << " bytes";
			AddResultString( ss.str().c_str() );
		}
		break;
	case DataField:
		{
			char number_str[128];
			AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 8, number_str, 128 );

			AddResultString( number_str );

			std::stringstream ss;
			ss << "Data: " << number_str;
			AddResultString( ss.str().c_str() );
			ss.str("");

			ss << "Data Field Byte: " << number_str;
			AddResultString( ss.str().c_str() );
		}
		break;
	case CrcField:
		{
			char number_str[128];
			AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 15, number_str, 128 );

			AddResultString( "CRC" );

			std::stringstream ss;
			ss << "CRC: " << number_str;
			AddResultString( ss.str().c_str() );
			ss.str("");

			ss << "CRC value: " << number_str;
			AddResultString( ss.str().c_str() );
		}
		break;	
	case AckField:
		{
			if( bool( frame.mData1 ) == true )
				AddResultString( "ACK" );
			else
				AddResultString( "NAK" );
		}
		break;	
	case CanError:
		{
			AddResultString( "E" );
			AddResultString( "Error" );
		}
		break;
	}
}
void MDIOAnalyzerResults::GenerateTransactionTabularText( U64 /*transaction_id*/, DisplayBase /*display_base*/ )
{
	ClearResultStrings();
	AddResultString( "not supported" );
}
void MDIOAnalyzerResults::GeneratePacketTabularText( U64 /*packet_id*/, DisplayBase /*display_base*/ )
{
	ClearResultStrings();
	AddResultString( "not supported" );
}
void AtmelSWIAnalyzerResults::GenerateBubbleText(U64 frame_index, Channel& channel, DisplayBase display_base)
{
	const int BUFF_SIZE = 128;
	char number_str[BUFF_SIZE];
	ClearResultStrings();
	Frame f = GetFrame(frame_index);

	if (f.mType == FrameToken)
	{
		if (f.mData1 == SWI_Wake)
		{
			AddResultString("Wake");
			AddResultString("Token Wake");
		} else if (f.mData1 == SWI_One) {
			AddResultString("1");
			AddResultString("One");
			AddResultString("Token One");
		} else if (f.mData1 == SWI_Zero) {
			AddResultString("0");
			AddResultString("Zero");
			AddResultString("Token Zero");
		}

	} else if (f.mType == FrameByte) {
		AnalyzerHelpers::GetNumberString(f.mData1, display_base, 8, number_str, BUFF_SIZE);
		AddResultString(number_str);

	} else if (f.mType == FrameChecksum) {

		std::vector<std::string> texts;
		GetTextsForChecksumFrame(f, display_base, texts);

		std::vector<std::string>::iterator i(texts.begin());
		while (i != texts.end())
		{
			AddResultString(i->c_str());
			++i;
		}

	} else if (f.mType == FrameFlag) {
		AnalyzerHelpers::GetNumberString(f.mData1, display_base, 8, number_str, BUFF_SIZE);
		AddResultString(number_str);
		if (f.mData2)
		{
			const char* FlagName = GetFlagName(static_cast<SWI_Flag>(f.mData1));
			AddResultString(FlagName);
			AddResultString("Flag ", FlagName, " (", number_str, ")");
		} else {
			AddResultString("Bad Flag (", number_str, ")");
		}

	} else if (f.mType == FrameCount) {
		AnalyzerHelpers::GetNumberString(f.mData1, display_base, 8, number_str, BUFF_SIZE);
		AddResultString(number_str);
		AddResultString("Count (", number_str, ")");

	} else if (f.mType == FramePacketSegment) {

		std::vector<std::string> texts;
		GetTextsForPacketSegmentFrame(f, display_base, texts);

		std::vector<std::string>::iterator i(texts.begin());
		while (i != texts.end())
		{
			AddResultString(i->c_str());
			++i;
		}
	}
}
void iso7816AnalyzerResults::GenerateBubbleText(U64 frame_index, Channel& channel, DisplayBase display_base)  //unrefereced vars commented out to remove warnings.
{
	char number_str[128];
    //we only need to pay attention to 'channel' if we're making bubbles for more than one channel (as set by AddChannelBubblesWillAppearOn)
    ClearResultStrings();
    Frame frame = GetFrame(frame_index);

	if (channel == mSettings->mResetChannel)
	{
		switch (frame.mFlags)
		{
		case ATR:
			AddResultString("A");
			AddResultString("ATR");
			AddResultString("ATR");
			break;

		case PPS:
			AddResultString("P");
			AddResultString("PPS");
			AddResultString("PPS: ", ((iso7816Analyzer*)mAnalyzer)->GetDetails(static_cast<int>(frame.mData1)).c_str());
			break;

		default:
			break;
		}
	}
	else
	{
		switch (frame.mFlags)
		{
		case 0:
			AnalyzerHelpers::GetNumberString(frame.mData1, display_base, 8, number_str, sizeof(number_str));
			AddResultString(number_str);
			break;

		case INVERSE:
			AddResultString("I");
			AddResultString("INV");
			AddResultString("Hdr(INVERSE)");
			break;

		case DIRECT:
			AddResultString("D");
			AddResultString("DIR");
			AddResultString("Hdr(DIRECT)");
			break;

		case ATR:
			break;

		case PPS:
			break;

		default:
			AddResultString("?");
			AnalyzerHelpers::GetNumberString(frame.mFlags, display_base, 8, number_str, sizeof(number_str));
			AddResultString(number_str);
			break;
		}
	}
}