Ejemplo n.º 1
0
/*------------------------------------------------------------------------------------------------------------*/	
void telnet_thread()
	{
		static struct TELNET_SESSION telnet_session;
		struct STDOUT oldstream;
		char Data; 
		int i;
		
		// keine alte Verbindung offen?
		if ( telnet_session.SOCKET == NO_SOCKET_USED )
		{ 	
			// auf neue Verbindung testen
			telnet_session.SOCKET = CheckPortRequest( TELNET_PORT );
			if ( telnet_session.SOCKET != NO_SOCKET_USED )
			{	
				STDOUT_save( &oldstream );
				STDOUT_set( _TCP, telnet_session.SOCKET );
				// Wenn ja, Startmeldung ausgeben und startzustand herstellen für telnet
				printf_P( PSTR( "Welcome on Tiny-Telnetserver 0.2!\r\n"
								"Und, los geht's...!!! (\"help\" hilft :-))\r\n> " ));
				STDOUT_restore( &oldstream );

				// TELNET_BUFFER leeren und auf Ausgangszustand setzen
				telnet_session.STATE = 0;
				telnet_session.POS = 0;
				telnet_session.BUFFER[0] = '\0';
				telnet_session.STATE = 0;
				
				FlushSocketData( telnet_session.SOCKET );
			}
		}
		// Wenn alte Verbindung offen hier weiter:
		else
		{
			// checken, ob noch offen ist
			if( CheckSocketState( telnet_session.SOCKET ) == SOCKET_NOT_USE )
			{
				CloseTCPSocket( telnet_session.SOCKET );
				telnet_session.SOCKET = NO_SOCKET_USED;
				return;
			}

			// Auf neue Daten zum zusammenbauen testen
			// hier wird der TELNET_BUFFER aufgefüllt bis 0x0a oder 0x0d eintreffen. der Puffer ist statisch
			// Wenn ein 0x0a oder 0x0d empfangen wurde, wird der TELNET_STATE auf 1 gesetzt, damit er verarbeitet werden kann
			if ( telnet_session.STATE == 0 )
			{	
				
				while( GetBytesInSocketData( telnet_session.SOCKET ) >= 1 )
				{
					Data = ( GetByteFromSocketData ( telnet_session.SOCKET ) );
					if ( Data != 0x0a && Data <= 0x7f)
					{
						if ( telnet_session.POS < TELNET_BUFFER_LEN )
						{
							telnet_session.BUFFER[ telnet_session.POS++ ] = Data;
							telnet_session.BUFFER[ telnet_session.POS ] = '\0';
						}
						if ( Data == 0x0d )
						{
							telnet_session.STATE = 1;
							break;
						}
					}
				}
			}	

			// Wenn TELNET_BUFFER eine Zeile vollständig hat gehts hier weiter
			if ( telnet_session.STATE == 1 )
			{

				STDOUT_save( &oldstream );
				STDOUT_set( _TCP, telnet_session.SOCKET );

				telnet_session.argc = TELNET_pharse( telnet_session.BUFFER, telnet_session.argv, MAX_ARGC );
				TELNET_runcmd( telnet_session.argc, telnet_session.argv );

				// auf QUIT checken
				if ( !strcmp_P( telnet_session.argv[ 0 ] , PSTR("quit") ) ) 
				{
					// Socket schließen
					printf_P( PSTR("Verbindung wird geschlossen\r\n") );
					STDOUT_Flush();
					STDOUT_set( RS232, 0);
					CloseTCPSocket( telnet_session.SOCKET );
					telnet_session.SOCKET = NO_SOCKET_USED;
					return;
				}
				else if( !strcmp_P( telnet_session.argv[ 0 ] , PSTR("help") ) )
				{
					printf_P( PSTR("Folgende Befehle sind vorhanden:\r\n\r\n") );
					for( i = 0 ; i < MAX_TELNET_ENTRYS ; i++ )
					{
						if ( telnet_cmd_table[ i ].functionname != NULL )
						{
							printf_P( telnet_cmd_table[ i ].functionname );
							printf_P( PSTR("\r\n") );
						}
					}
				}

				printf_P( PSTR("> ") );
				
				STDOUT_restore( &oldstream );

				telnet_session.STATE = 0;
				telnet_session.POS = 0;
				telnet_session.BUFFER[0] = '\0';
				telnet_session.STATE = 0;
			}
		}
	}
Ejemplo n.º 2
0
/*------------------------------------------------------------------------------------------------------------*/
void mp3client_stream( void )
{
	static unsigned int temp;
	char sreg_tmp;

	
	timer0_stop();
	
	// Wenn slowstart auf 0 steht Decoder nicht befüttern, sonst warten bis 7/8 voll
	if ( slowstart == 0 )
		VS10xx_flush_from_FIFO( MP3_FIFO );
	else
		if ( Get_Bytes_in_FIFO ( MP3_FIFO ) > ( mp3_buffer_size / 8 ) * 7 ) slowstart = 0;
	
	// Verbindung wirklich noch offen
	if( CheckSocketState( MP3_SOCKET ) == SOCKET_NOT_USE )
	{
		CloseTCPSocket( MP3_SOCKET );
		MP3_SOCKET = NO_SOCKET_USED;
	}
	else
	{
		sreg_tmp = SREG;
		sei();
		
		// Datenpuffer auffrischen mit neuen daten von TCP-Verbindung
		while ( GetBytesInSocketData( MP3_SOCKET ) >= MP3TCPtranslen && Get_FIFOrestsize ( MP3_FIFO ) > MP3TCPtranslen && metainfolen == 0 )
		{
			// Wenn die transferlänge zum nächsten Metaint kleiner als translen zwischen tcp und mp3 buffer ist, nur diese
			// kopieren damit danach der metaint eingelesen werden kann
			if ( metaint - ( metaintcounter%metaint ) < MP3TCPtranslen && metaint != 0)
			{
				LED_on(1);
				temp = GetSocketDataToFIFO ( MP3_SOCKET, MP3_FIFO, metaint - ( metaintcounter%metaint ) );
				totalbytes = totalbytes + temp;
				metaintcounter = metaintcounter + temp;
				LED_off(1);
			}
			else
			{	
				LED_on(1);
				temp = GetSocketDataToFIFO ( MP3_SOCKET, MP3_FIFO, MP3TCPtranslen );
				totalbytes = totalbytes + temp;
				metaintcounter = metaintcounter + temp;
				LED_off(1);
			}
			
			if ( metaintcounter%metaint == 0 && metaint != 0 )
			{
				// checkt und wartet ob mehr als 1 Byte im Puffer ist
				while ( GetBytesInSocketData( MP3_SOCKET ) <= 0 );
				// lese Byte und errechne die metalänge
				metainfolen = GetByteFromSocketData ( MP3_SOCKET ) * 16 ;
				
				break;
			}
		}

		SREG = sreg_tmp;
	}
	
	timer0_free();

}
Ejemplo n.º 3
0
/**
 * \brief Der Telnet-client an sich. Er wird zyklisch aufgerufen und schaut nach ob eine Verbindung auf den
 * registrierten Port eingegangen ist. Wenn ja holt er sich die Socketnummer der Verbindung und speichert diese.
 * Wenn eine Verbindung zustande gekommen ist wird diese wiederrum zyklisch nach neuen Daten abgefragt und entsprechend
 * reagiert.
 * \param 	NONE
 * \return	NONE
 */
void telnet_thread( void )
{
	struct STDOUT oldstream;
	char Data; 
	
	// keine alte Verbindung offen?
	if ( telnet_session.SOCKET == NO_SOCKET_USED )
	{ 	
		// auf neue Verbindung testen
		telnet_session.SOCKET = CheckPortRequest( TELNET_PORT );
		if ( telnet_session.SOCKET != NO_SOCKET_USED )
		{	
			STDOUT_save( &oldstream );
			STDOUT_set( _TCP, telnet_session.SOCKET );
			// Wenn ja, Startmeldung ausgeben und startzustand herstellen für telnet
			printf_P( PSTR( "Und, los geht's...!!! (\"help\" hilft :-))\r\n> " ));
			STDOUT_restore( &oldstream );

			// TELNET_BUFFER leeren und auf Ausgangszustand setzen
			telnet_session.STATE = 0;
			telnet_session.POS = 0;
			telnet_session.BUFFER[0] = '\0';
			telnet_session.STATE = 0;

			FlushSocketData( telnet_session.SOCKET );
		}
	}
	// Wenn alte Verbindung offen hier weiter:
	else
	{
		// checken, ob noch offen ist
		if( CheckSocketState( telnet_session.SOCKET ) != SOCKET_READY )
		{
			telnet_session.SOCKET = NO_SOCKET_USED;
			return;
		}

		// Auf neue Daten zum zusammenbauen testen
		// hier wird der TELNET_BUFFER aufgefüllt bis 0x0a oder 0x0d eintreffen. der Puffer ist statisch
		// Wenn ein 0x0a oder 0x0d empfangen wurde, wird der TELNET_STATE auf 1 gesetzt, damit er verarbeitet werden kann
		if ( telnet_session.STATE == 0 )
		{	

			while( GetBytesInSocketData( telnet_session.SOCKET ) >= 1 )
			{
				Data = ( GetByteFromSocketData ( telnet_session.SOCKET ) );
				if ( Data != 0x0a && Data <= 0x7f)
				{
					if ( telnet_session.POS < TELNET_BUFFER_LEN )
					{
						telnet_session.BUFFER[ telnet_session.POS++ ] = Data;
						telnet_session.BUFFER[ telnet_session.POS ] = '\0';
					}
					if ( Data == 0x0d )
					{
						telnet_session.STATE = 1;
						break;
					}
				}
			}
		}	

		// Wenn TELNET_BUFFER eine Zeile vollständig hat gehts hier weiter
		if ( telnet_session.STATE == 1 )
		{

			STDOUT_save( &oldstream );
			STDOUT_set( _TCP, telnet_session.SOCKET );

			telnet_session.argc = SHELL_pharse( telnet_session.BUFFER, telnet_session.argv, MAX_ARGC );

			// auf QUIT checken
			if ( !strcmp_P( telnet_session.argv[ 0 ] , PSTR("quit") ) ) 
			{
				// Socket schließen
				printf_P( PSTR("Quiting\r\n") );
				STDOUT_Flush();
				STDOUT_set( RS232, 0);
				CloseTCPSocket( telnet_session.SOCKET );
				telnet_session.SOCKET = NO_SOCKET_USED;
				return;
			} else 
			/************************************************************************/
			/* help value for openhab just intended to simulate a connection        */
			/************************************************************************/
			if(!strcmp_P( telnet_session.argv[ 0 ] , PSTR("value") )){
				printf_P( PSTR("openhab") );
				STDOUT_Flush();
			}
			else
			{
				SHELL_runcmd( telnet_session.argc, telnet_session.argv );
			}

			printf_P( PSTR("> ") );

			STDOUT_restore( &oldstream );

			telnet_session.STATE = 0;
			telnet_session.POS = 0;
			telnet_session.BUFFER[0] = '\0';
			telnet_session.STATE = 0;
		}
	}
}
Ejemplo n.º 4
0
/*------------------------------------------------------------------------------------------------------------*/
void mp3client_thread( void )
{
	#define bandwidthhis	16
	unsigned char i;
	static unsigned long totalbytesold[bandwidthhis],bandwidth;
	static unsigned char y;	
	static unsigned int temp;
	timer0_stop();
	
	STDOUT_Set_RS232 ();
	
	if ( MP3_SOCKET == NO_SOCKET_USED )
	{ 	
		// keine Verbindung offen? Trafficcounter zurücksetzen
		y=0;
		metaintcounter=0;
		slowstart = 1;
	}
	else
	{	
		// Verbindung wirklich noch offen
		if( CheckSocketState( MP3_SOCKET ) == SOCKET_NOT_USE )
		{
			CloseTCPSocket( MP3_SOCKET );
			MP3_SOCKET = NO_SOCKET_USED;
		}
		else
		{		
			// Wenn Puffer auf unter 1/8 gelaufen ist slowstart setzen 
			if ( Get_Bytes_in_FIFO ( MP3_FIFO ) < mp3_buffer_size / 8 ) slowstart = 1;			
		
/*			// Datenpuffer auffrischen mit neuen daten von TCP-Verbindung
			while ( GetBytesInSocketData( MP3_SOCKET ) >= MP3TCPtranslen && Get_FIFOrestsize ( MP3_FIFO ) > MP3TCPtranslen && metainfolen == 0 )
			{
				// Wenn die transferlänge zum nächsten Metaint kleiner als translen zwischen tcp und mp3 buffer ist, nur diese
				// kopieren damit danach der metaint eingelesen werden kann
				if ( metaint - ( metaintcounter%metaint ) < MP3TCPtranslen && metaint != 0)
				{
					LED_on(1);
					temp = GetSocketDataToFIFO ( MP3_SOCKET, MP3_FIFO, metaint - ( metaintcounter%metaint ) );
					totalbytes = totalbytes + temp;
					metaintcounter = metaintcounter + temp;
					LED_off(1);
				}
				else
				{	
					LED_on(1);
					temp = GetSocketDataToFIFO ( MP3_SOCKET, MP3_FIFO, MP3TCPtranslen );
					totalbytes = totalbytes + temp;
					metaintcounter = metaintcounter + temp;
					LED_off(1);
				}
				
				if ( metaintcounter%metaint == 0 && metaint != 0 )
				{
					// checkt und wartet ob mehr als 1 Byte im Puffer ist
					while ( GetBytesInSocketData( MP3_SOCKET ) <= 0 );
					// lese Byte und errechne die metalänge
					metainfolen = GetByteFromSocketData ( MP3_SOCKET ) * 16 ;
					
					break;
				}
    		}
*/			
			// Wenn der metaintcounter auf einen metaint steht, den metaint lesen und ausgeben
			if ( metainfolen != 0 )
			{						
				mp3client_readmetainfo( MP3_SOCKET, metainfolen );
				metainfolen = 0;
			}

			// Counter schon bei 0, wenn ja stats updaten
			if ( CLOCK_GetCountdownTimer ( mp3timer ) == 0 )
			{			
				bandwidth = 0;	

				// traffic aufaddieren
				for ( i = 0 ; i < bandwidthhis ; i++)
					bandwidth = bandwidth + totalbytesold[ i ];	
	
				// bandwidth berechnen alle 0,5 sekunden
				bandwidth = ( bandwidth / bandwidthhis ) * 2;
				
				// stats sichern
				mp3clientupdate( bandwidth, GetBytesInSocketData( MP3_SOCKET ) , Get_Bytes_in_FIFO ( MP3_FIFO ), VS10xx_get_decodetime( ), verboselevel );		

				// wenn verboselevel gesetzt ausgeben
				if ( verboselevel != 0)
					printf_P( PSTR("\r%5d(TCP %4d)Bytes on FIFO, bandwidth:%3ldkbit/s(%2dkb/s)"), Get_Bytes_in_FIFO ( MP3_FIFO ), GetBytesInSocketData( MP3_SOCKET ), ( bandwidth * 8 ) / 1024, ( bandwidth * 8 ) / 8192 );	

				// zähler für bandwidth zurücksetzten
				if ( y < bandwidthhis )
				{
					totalbytesold[y] = totalbytes;
				}
				else
				{
					y = 0;
					totalbytesold[y] = totalbytes;
				}
				y++;
				totalbytes = 0;	

				// Counter neu starten 0,5 Sekunden
				CLOCK_SetCountdownTimer ( mp3timer, 47, MSECOUND );
			}
		}
	}
	
	timer0_free();
	return;
}