Index: /firmware/FSC/src/FSC_eth_with_user_interface.c
===================================================================
--- /firmware/FSC/src/FSC_eth_with_user_interface.c	(revision 10909)
+++ /firmware/FSC/src/FSC_eth_with_user_interface.c	(revision 10910)
@@ -34,8 +34,6 @@
 	bool once_told_you = true;
 	bool debug_mode = false;
-	
-// ETHERNET VARS
-U08 downloaded_bytes;
-
+
+	
 //-----------------------------------------------------------------------------
 //   M A I N    ---   M A I N    ---   M A I N    ---   M A I N    ---  M A I N    
@@ -43,4 +41,7 @@
 int main(void)
 {
+	U08 highbyte;
+	U08 lowbyte;
+
 	app_init();		  // Setup: Watchdog and I/Os
 	usart_init();
@@ -59,13 +60,16 @@
 	
 for ( U08 i=0; i < (RESISTANCE_CHANNELS/8); ++i ) {
-	ad7719_enables[i]=0xFF;
+	ad7719_enables[i]=0x00;
 	ad7719_channels_ready[i]=0;
 	}
-for ( U08 i=0; i < (VOLTAGE_CHANNELS/8); ++i ) {
-	adc_enables[i]=0x00;
+for ( U08 i=0; i < (VOLTAGE_REGS); ++i ) {
+	if (i < (VOLTAGE_REGS)-1)
+		adc_enables[i]=0xFF;
+	else
+		adc_enables[i]=0x0F;
 	adc_channels_ready[i]=0;
 }
 
-	static U08 welcome[]="welcome to:\n FSC command interface 0.1 \n build: ??.05.2010\n";
+	static U08 welcome[]="FSC 0.2 \n build: 05.06.2010 - 12:57\n";
 	usart_write_str(welcome);
 	/*
@@ -94,6 +98,6 @@
 	{
 		if (get_S0_RX_RSR() != 0) { // we have something to read
-			downloaded_bytes = w5100_get_RX(ETH_READ_BUFFER_SIZE, true);
-			parse_w5300_incoming( downloaded_bytes );
+			
+			parse_w5300_incoming( w5100_get_RX(ETH_READ_BUFFER_SIZE, true) );
 		}
 	}
@@ -107,4 +111,7 @@
 			usart_write_U32(sec ,8);
 			print_adc_nicely(false,true);
+			//print_adc_stupid();
+			reset_voltage_done();
+			reset_voltage_values();
 			telegram_start();
 			w5100_set_TX((U08*) adc_values, ADC_VALUES_LEN_BYTE);
@@ -115,4 +122,6 @@
 			adc_values_printed = true;
 			print_adc_nicely(true,true);
+			//print_adc_stupid();
+			//reset_voltage_done();
 			telegram_start();
 			w5100_set_TX((U08*) adc_values, ADC_VALUES_LEN_BYTE);
@@ -135,4 +144,5 @@
 			ad7719_values_printed = true;
 			print_ad7719_nicely(true,true);
+			reset_resistance_done();
 			telegram_start();
 			w5100_set_TX((U08*) ad7719_values, AD7719_VALUES_LEN_BYTE);
@@ -187,5 +197,6 @@
 	//	-It is not allowed to send more than one command between two '\n'
 	if (usart_rx_ready){ 
-		void MSR_parser();
+		//parse_ascii();
+		MSR_parser();
 	}
 //----------------------------------------------------------------------------
@@ -193,7 +204,15 @@
 	//IF ATmega internal ADC did finish a conversion --every 200us
 	if ( (ADCSRA & (1<<ADIF)) && !adc_measured_all) {
-		*adc_current_reading = (U16)ADCL;
-		*adc_current_reading += (U16)ADCH<<8;
+		lowbyte = ADCL;
+		highbyte = ADCH;
+		ADCSRA |= 1<<ADIF;
+		*adc_current_reading = ((U16)highbyte<<8) | ((U16)lowbyte);
+		if (debug_mode) {
+				usart_write_U16_hex(*adc_current_reading);
+				usart_write_crlf();
+		}
+		
 		if (*adc_readings_since_last_muxing == ADC_READINGS_UNTIL_SETTLED+adc_readings_until_mean-1) {
+			adc_values[*adc_current_channel] += *adc_current_reading;
 			adc_channels_ready[*adc_current_channel/8] |= (1<<(*adc_current_channel%8));
 			*adc_current_channel = increase_adc (*adc_current_channel);
@@ -201,8 +220,18 @@
 			Set_V_Muxer(*adc_current_channel);
 			*adc_readings_since_last_muxing = 0;
-			_delay_ms(10);
+			_delay_ms(10); // this is a muxer delay			
 		}
 		else if (adc_readings_since_last_muxing >= ADC_READINGS_UNTIL_SETTLED-1) {
 			adc_values[*adc_current_channel] += *adc_current_reading;
+			if (debug_mode) {
+				usart_write_str((pU08)"ch:");
+				usart_write_U08(*adc_current_channel,4);
+				usart_write_str((pU08)" v:");
+				usart_write_U16_hex(*adc_current_reading);
+				usart_write_str((pU08)" sum:");
+				usart_write_U16(adc_values[*adc_current_channel],8);
+				usart_write_crlf();
+			}
+
 			++(*adc_readings_since_last_muxing);
 		}
@@ -212,4 +241,5 @@
 
 	}
+	
 //----------------------------------------------------------------------------
 
Index: /firmware/FSC/src/FSC_test.c
===================================================================
--- /firmware/FSC/src/FSC_test.c	(revision 10909)
+++ /firmware/FSC/src/FSC_test.c	(revision 10910)
@@ -55,6 +55,6 @@
 // ATMEGA ADC global variables
 	U08 adc_values[VOLTAGE_CHANNELS]; // stores measured voltage in steps of 16mV
-	U08 adc_enables[VOLTAGE_CHANNELS/8];
-	U08 adc_channels_ready[VOLTAGE_CHANNELS/8];
+	U08 adc_enables[VOLTAGE_REGS];
+	U08 adc_channels_ready[VOLTAGE_REGS];
 	U08 adc_readings_since_last_muxing = 0;
 	U08 adc_current_channel = 0;
Index: /firmware/FSC/src/application.c
===================================================================
--- /firmware/FSC/src/application.c	(revision 10909)
+++ /firmware/FSC/src/application.c	(revision 10910)
@@ -19,6 +19,6 @@
 
 U32 *ad7719_values 						= (U32*)&FSCregister[68];
-U08 *ad7719_enables 					= &FSCregister[32];
-U08 *ad7719_channels_ready 				= &FSCregister[50];
+U08 *ad7719_enables 					= &FSCregister[30];
+U08 *ad7719_channels_ready 				= &FSCregister[49];
 U08 *ad7719_readings_since_last_muxing 	= &FSCregister[14];
 U08 *ad7719_current_channel 			= &FSCregister[15];
@@ -26,6 +26,6 @@
 
 U16 *adc_values 						= (U16*) &FSCregister[324];
-U08 *adc_enables 						= &FSCregister[40];
-U08 *adc_channels_ready 				= &FSCregister[58];
+U08 *adc_enables 						= &FSCregister[38];
+U08 *adc_channels_ready 				= &FSCregister[57];
 U08 *adc_readings_since_last_muxing 	= &FSCregister[20];
 U08 *adc_current_channel 				= &FSCregister[21];
@@ -178,6 +178,17 @@
 	{
 		effective_channel = (channel + increase) % (VOLTAGE_CHANNELS);
-		if (adc_enables[effective_channel/8] & (1<<effective_channel%8))
+		if (adc_enables[effective_channel/8] & (1<<effective_channel%8)) {
+			if (debug_mode)
+			{
+				usart_write_U08(effective_channel,3);
+				usart_write_crlf();
+			}
 			return effective_channel;
+		}
+	}
+	if (debug_mode)
+	{
+		usart_write_U08(channel,3);
+		usart_write_crlf();
 	}
 	return channel;
@@ -197,5 +208,5 @@
 void check_if_measured_all() {
 	adc_measured_all = true;
-	for ( U08 i=0; i<(VOLTAGE_CHANNELS/8); ++i ) {
+	for ( U08 i=0; i<(VOLTAGE_REGS); ++i ) {
 		if ((adc_enables[i] ^ adc_channels_ready[i]) != 0x00) {
 			adc_measured_all = false;
@@ -214,9 +225,30 @@
 }
 
-
+// an U08 array containts bitmaps, which encode, which channel is enabled and which is not.
+// a measurement is done, when all (or more) enabled channels were already measured.
+// a similar U08 array contains a bitmap, encoding which channels are already done.
+//  note: "or more" above is important, if we check to strictly, 
+//	we will never finish, in case a disabled channel get measured by any mistake...
+//
+//	lets assume:
+//	enabled = 1110.0011		1110.0011
+// 	done 	= 1111.0011		0111.0010
+//
+//	and		= 1110.0011		0110.0010
+//	nand	= 0001.0011		1001.1101
+//	or		= 1111.0011		1111.0011
+//	xor		= 0001.0000		1001.0001
+//	
+//											
+// (en xor done) and enabled =
+//	xor		= 0001.0000		1001.0001
+//	enabled = 1110.0011		1110.0011
+//			  ---------		---------
+//			  0000.0000		1000.0001
+// if this statement evaluates to zero, 
 bool check_if_adc_measurement_done(){
 	adc_measured_all = true;
-	for ( U08 i=0; i<VOLTAGE_CHANNELS/8; ++i ) {
-		if ((adc_enables[i] ^ adc_channels_ready[i]) != 0x00) {
+	for ( U08 i=0; i<VOLTAGE_REGS; ++i ) {
+		if (( (adc_enables[i] ^ adc_channels_ready[i]) & adc_enables[i] )  != 0x00) {
 			adc_measured_all = false;
 			break;
@@ -229,5 +261,5 @@
 	ad7719_measured_all = true;
 	for ( U08 i=0; i<RESISTANCE_CHANNELS/8; ++i ) {
-		if ((ad7719_enables[i] ^ ad7719_channels_ready[i]) != 0x00) {
+		if (( (ad7719_enables[i] ^ ad7719_channels_ready[i]) & ad7719_enables[i]) != 0x00) {
 			ad7719_measured_all = false;
 			break;
Index: /firmware/FSC/src/application.h
===================================================================
--- /firmware/FSC/src/application.h	(revision 10909)
+++ /firmware/FSC/src/application.h	(revision 10910)
@@ -7,5 +7,5 @@
 // in order to implement the "registers" I work with a quite long 
 //  char-array like this:
-# define FSC_REGISTER_LENGTH 254
+# define FSC_REGISTER_LENGTH 492
 extern U08 FSCregister[FSC_REGISTER_LENGTH];
 // but this register is not only accessible by
@@ -26,5 +26,5 @@
 
 extern U16 *adc_values 						;
-#define ADC_VALUES_LEN_BYTE 152
+#define ADC_VALUES_LEN_BYTE 168
 extern U08 *adc_enables 						;
 extern U08 *adc_channels_ready 				;
@@ -70,4 +70,5 @@
 	
 	#define VOLTAGE_CHANNELS 84
+	#define VOLTAGE_REGS 11
 	#define ADC_READINGS_UNTIL_SETTLED 1
 #endif
@@ -90,5 +91,5 @@
 
 // ATMEGA ADC global variables
-	#define adc_readings_until_mean 250
+	#define adc_readings_until_mean 40
 	extern bool adc_measured_all;
 	extern bool adc_values_printed;
Index: /firmware/FSC/src/atmega_adc.c
===================================================================
--- /firmware/FSC/src/atmega_adc.c	(revision 10909)
+++ /firmware/FSC/src/atmega_adc.c	(revision 10910)
@@ -15,5 +15,5 @@
 	ADMUX &= ~(1<<REFS0); 
 	ADMUX &= ~(1<<REFS1); 	//REFS = 00 --> use external reference voltage.
-	ADMUX |= 1<<ADLAR;		//ADLAR =1 	--> left adjust ac result in ADCH register --> 8bit resolution only.				
+	//ADMUX |= 1<<ADLAR;		//ADLAR =1 	--> left adjust ac result in ADCH register --> 8bit resolution only.				
 	ADMUX |= (0x1F & 0x06); //MUX = 0x06 --> Pin ADC6 = PA6 is used as ADC input pin.
 	
Index: /firmware/FSC/src/muxer_fsc.c
===================================================================
--- /firmware/FSC/src/muxer_fsc.c	(revision 10909)
+++ /firmware/FSC/src/muxer_fsc.c	(revision 10910)
@@ -1,4 +1,4 @@
 #include "muxer_fsc.h"
-
+#include "usart.h"
 // Sets voltage Muxer to current channel
 // this is a Muxing, and therefor the adc might need some time to settle.
@@ -39,8 +39,8 @@
 				break;
 			case 2:
-				SB = 0x58; //0101.0010
+				SB = 0x52; //0101.0010
 				break;
 			case 3:
-				SB = 0x58; //0101.0011
+				SB = 0x53; //0101.0011
 				break;
 		} // end of switch-case
Index: /firmware/FSC/src/output.c
===================================================================
--- /firmware/FSC/src/output.c	(revision 10909)
+++ /firmware/FSC/src/output.c	(revision 10910)
@@ -7,14 +7,14 @@
 void print_status() {
 	usart_write_str((pU08)"adc status:\n");
-	for (U08 i=0; i< VOLTAGE_CHANNELS/8;++i) {
+	for (U08 i=0; i< VOLTAGE_REGS;++i) {
 		usart_write_U08_bin(adc_enables[i]);	
 		usart_write_char(' ');
 	}
-	usart_write_char('\n');
-	for (U08 i=0; i< VOLTAGE_CHANNELS/8;++i){
+	usart_write_crlf();
+	for (U08 i=0; i< VOLTAGE_REGS;++i){
 		usart_write_U08_bin(adc_channels_ready[i]);
 		usart_write_char(' ');
 	}
-	usart_write_char('\n');
+	usart_write_crlf();
 
 	usart_write_str((pU08)"ad7719 status:\n");
@@ -23,15 +23,15 @@
 		usart_write_char(' ');
 	}
-	usart_write_char('\n');
+	usart_write_crlf();
 	for (U08 i=0; i< RESISTANCE_CHANNELS/8;++i){
 		usart_write_U08_bin(ad7719_channels_ready[i]);
 		usart_write_char(' ');
 	}
-	usart_write_char('\n');
+	usart_write_crlf();
 
 	usart_write_str((pU08)"time:");
 	usart_write_U32(sec,10);
 	usart_write_str((pU08)" sec.\n");
-
+/*
 	usart_write_str((pU08)"adc measured all: ");
 	if (adc_measured_all)
@@ -48,10 +48,16 @@
 	usart_write_str((pU08)"adc current channel:");
 	usart_write_U08(*adc_current_channel,2);
-	usart_write_char('\n');
+	usart_write_crlf();
 
 	usart_write_str((pU08)"ad7719 current channel:");
 	usart_write_U08(*ad7719_current_channel,2);
-	usart_write_char('\n');
-
+	usart_write_crlf();
+	
+	usart_write_str((pU08)"mux SB:");
+	usart_write_U08_hex(PORTC);
+	usart_write_str((pU08)" SA:");
+	usart_write_U08_hex(PORTA);
+	usart_write_crlf();
+*/
 }
 void print_adc_nicely() {
@@ -92,5 +98,5 @@
 			usart_write_str((pU08)" ");	
 		} else {
-			usart_write_str((pU08)"         ");	
+			usart_write_str((pU08)"       ");	
 		}
 		//usart_write_char('\n');
@@ -114,5 +120,5 @@
 }
 
-void adc_output(U08 channel, U08 data) {
+void adc_output(U08 channel, U16 data) {
 
 //	if (channel < 40) 
@@ -167,5 +173,5 @@
 	//usart_write_U08(channel,2); // Numbers 1...8
 	usart_write_char(':'); 
-	usart_write_U16((U16)data*16, 4); //data
+	usart_write_U16(data/(adc_readings_until_mean/4), 7); //data
 }
 
@@ -182,2 +188,20 @@
 	w5100_set_TX(eth_write_buffer, 2); 
 }
+
+void print_help(){
+	usart_write_str((pU08)"printing help: -not yet- \n"); 
+}
+
+void print_adc_stupid() {
+	usart_write_str((pU08)"printing voltages in mV - stupid mode:\n");
+	for (U08 i = 0 ; i < VOLTAGE_CHANNELS ; ++i) {
+		usart_write_str((pU08)"ch:");
+		usart_write_U08(i,3);
+		usart_write_char(' ');
+		usart_write_U16_hex(adc_values[i]);
+		usart_write_char(' ');
+		usart_write_U16(adc_values[i],7);
+		usart_write_crlf(); 
+	}
+	usart_write_char('\n');
+}
Index: /firmware/FSC/src/output.h
===================================================================
--- /firmware/FSC/src/output.h	(revision 10909)
+++ /firmware/FSC/src/output.h	(revision 10910)
@@ -5,11 +5,12 @@
 
 void ad7719_output(U08 channel, U32 data);
-void adc_output(U08 channel, U08 data);
+void adc_output(U08 channel, U16 data);
 void adc_output_all();
 void print_ad7719_nicely();
 void print_adc_nicely();
+void print_adc_stupid();
 void print_status() ;
 
-
+void print_help();
 void telegram_start();
 
Index: /firmware/FSC/src/parser.c
===================================================================
--- /firmware/FSC/src/parser.c	(revision 10909)
+++ /firmware/FSC/src/parser.c	(revision 10910)
@@ -41,5 +41,5 @@
 		case 'g':			// GET the voltage/current/humidity channels, which are enabled
 			once_told_you = false;
-			for ( U08 i=0; i<VOLTAGE_CHANNELS/8; ++i ) {
+			for ( U08 i=0; i<VOLTAGE_REGS; ++i ) {
 				adc_channels_ready[i]=0;
 			}
@@ -107,5 +107,5 @@
 }
 */
-/*
+
 
 // this is the recent MSR parser
@@ -242,13 +242,12 @@
 			case 'G': 			// GET the Temperature channels, which are enabled
 				ad7719_values_printed = false;
-				for ( U08 i=0; i<RESISTANCE_CHANNELS/8; ++i ) {
-					ad7719_channels_ready[i]=0;
-				}
-				break;
+				reset_resistance_done();
+				reset_resistance_values();				
+				break;
+				
 			case 'g':			// GET the voltage/current/humidity channels, which are enabled
 				adc_values_printed = false;
-				for ( U08 i=0; i<VOLTAGE_CHANNELS/8; ++i ) {
-					adc_channels_ready[i]=0;
-				}
+				reset_voltage_done();
+				reset_voltage_values();
 				break;
 
@@ -264,17 +263,21 @@
 					ad7719_print_endless = false;
 				break;		
+			
+			case 's':
+				print_status();
+				//print_adc_enable_status(true);
+				//usart_write_char('\n');
+
+				//print_ad7719_enable_status(true);
+				//usart_write_char('\n');
+			
+				//usart_write_str((pU08)"time:");
+				//usart_write_float((float)local_ms/1000 , 1,7);
+				//usart_write_str((pU08)" sec.\n");
+				break;	
 				
-
-			case 's':			
-				print_adc_enable_status(true);
-				usart_write_char('\n');
-
-				print_ad7719_enable_status(true);
-				usart_write_char('\n');
-			
-				usart_write_str((pU08)"time:");
-				usart_write_float((float)local_ms/1000 , 1,7);
-				usart_write_str((pU08)" sec.\n");
-				break;	
+			case 'S':
+				write_status_via_eth();
+				break;
 
 			case '!':
@@ -306,5 +309,5 @@
 }	// END of MSR_parser();
 
-*/
+
 
 ///////////////////////////////////////////////////////////////////////////////////////
@@ -342,5 +345,6 @@
 		case 's':	// return *s*tatus information
 			// this might take a lot of time... about... 25us per byte .. --> less than 25ms
-			w5100_set_TX(FSCregister, FSC_REGISTER_LENGTH);
+			write_status_via_eth();
+			//w5100_set_TX(FSCregister, FSC_REGISTER_LENGTH);
 			break;
 			
@@ -372,9 +376,22 @@
 	}
 }
+void reset_resistance_values(){
+	for (U08 i=0; i < RESISTANCE_CHANNELS; i++){
+		ad7719_values[i] = 0;
+	}
+}
+
+
 void reset_voltage_done(){
-	for (U08 i=0; i < (VOLTAGE_CHANNELS/8); i++){
+	for (U08 i=0; i < (VOLTAGE_REGS); i++){
 		adc_channels_ready[i] = 0;
 	}
 }
+void reset_voltage_values(){
+	for (U08 i=0; i < VOLTAGE_CHANNELS; i++){
+		adc_values[i] = 0;
+	}
+}
+
 void reset_done(){
 	reset_resistance_done();
@@ -387,2 +404,73 @@
 	w5100_set_TX(eth_write_buffer, 2); 
 }
+
+void write_status_via_eth() {
+	// take care: ethernet write buffer is just 32 bytes long.
+	eth_write_str("status: "); 				eth_writeln_str(nc_U32_to_hex(status));
+	// better switch off interrupts here:
+	// otherwise the numbers in time_sec and time_ms might get corrupt during output.
+	cli();
+	eth_write_str("time_s: "); 				eth_writeln_str(nc_U32_to_str(time_sec, 10));
+	eth_write_str("mili_s: "); 				eth_writeln_str(nc_U16_to_str(time_ms, 6));
+	sei();
+	
+	eth_write_str("R_ref : "); 				eth_writeln_str(nc_U16_to_str(ref_resistor, 6));
+	
+	eth_writeln_str("VOLTAGES\n");
+		eth_write_str("enable:"); 				
+		for (U08 i=0; i<4 ; i++){
+			eth_write_str(nc_U08_to_bin(adc_enables[i]));
+			// need to tweak here in order to get some nice spaces...
+			eth_write_buffer[eth_write_index] = ' ';
+			eth_write_index++;
+		}
+		eth_writeln_str(nc_U08_to_bin(adc_enables[4]));
+		
+		eth_write_str("  done:"); 				
+		for (U08 i=0; i<4 ; i++){
+			eth_write_str(nc_U08_to_bin(adc_channels_ready[i]));
+			// need to tweak here in order to get some nice spaces...
+			eth_write_buffer[eth_write_index] = ' ';
+			eth_write_index++;
+		}
+		eth_writeln_str(nc_U08_to_bin(adc_channels_ready[4]));
+
+		eth_write_str("values:"); 				
+		for (U08 i=0; i<73 ; i++){
+			eth_write_str(nc_U16_to_str(adc_values[i], 6) );
+			// need to tweak here in order to get some nice spaces...
+			eth_write_buffer[eth_write_index] = ' ';
+			eth_write_index++;
+		}
+		eth_writeln_str(nc_U16_to_str(adc_values[73], 6) );
+		
+	eth_writeln_str("RESISTANCES\n");
+		eth_write_str("enable:"); 				
+		for (U08 i=0; i<7 ; i++){
+			eth_write_str(nc_U08_to_bin(ad7719_enables[i]));
+			// need to tweak here in order to get some nice spaces...
+			eth_write_buffer[eth_write_index] = ' ';
+			eth_write_index++;
+		}
+		eth_writeln_str(nc_U08_to_bin(ad7719_enables[7]));
+		
+		eth_write_str("  done:"); 				
+		for (U08 i=0; i<7 ; i++){
+			eth_write_str(nc_U08_to_bin(ad7719_channels_ready[i]));
+			// need to tweak here in order to get some nice spaces...
+			eth_write_buffer[eth_write_index] = ' ';
+			eth_write_index++;
+		}
+		eth_writeln_str(nc_U08_to_bin(ad7719_channels_ready[7]));
+
+		eth_write_str("values:"); 				
+		for (U08 i=0; i<63 ; i++){
+			eth_write_str(nc_U32_to_str(ad7719_values[i], 10) );
+			// need to tweak here in order to get some nice spaces...
+			eth_write_buffer[eth_write_index] = ' ';
+			eth_write_index++;
+		}
+		eth_writeln_str(nc_U32_to_str(ad7719_values[63], 10) );
+		
+
+}
Index: /firmware/FSC/src/parser.h
===================================================================
--- /firmware/FSC/src/parser.h	(revision 10909)
+++ /firmware/FSC/src/parser.h	(revision 10910)
@@ -15,7 +15,12 @@
 void read_FSC_register();
 void reset_resistance_done();
+void reset_resistance_values();
 void reset_voltage_done();
+void reset_voltage_values();
 void reset_done();
 void simple_acknowledge();
 
+// this function will loop over the entire FSC register and output it in a human readable form.
+// I hope this is convenient.
+void write_status_via_eth();
 #endif
Index: /firmware/FSC/src/w5100_spi_interface.c
===================================================================
--- /firmware/FSC/src/w5100_spi_interface.c	(revision 10909)
+++ /firmware/FSC/src/w5100_spi_interface.c	(revision 10910)
@@ -8,4 +8,5 @@
 volatile U08 eth_write_buffer[ETH_WRITE_BUFFER_SIZE];
 
+U08 eth_write_index;
 //-----------------------------------------------------------------------------
 // INTERFACE CONTROL VARS
@@ -305,11 +306,5 @@
 	{
 		return 0;
-	}
-	usart_write_str((U08*)"sending via eth: with pointer:");
-	usart_write_U16_hex(string);
-	usart_write_str((U08*)" #of bytes: ");
-	usart_write_U16(NumBytes,4 );
-	usart_write_char(' \n');
-	
+	}	
 	U16 last_TX_write_pointer = get_S0_TX_WR();
 	U16 offset = last_TX_write_pointer & S0_TX_MASK;
@@ -340,9 +335,9 @@
 		upper_size = (S0_RX_MASK + 1) - offset;
 		lower_size = NumBytes - upper_size;
-		for (U08 i = 0; i < upper_size; ++i)
+		for (U16 i = 0; i < upper_size; ++i)
 		{
 			w5100_write(start_address + i, string[i]);
 		}
-		for (U08 i = 0; i < lower_size; ++i)
+		for (U16 i = 0; i < lower_size; ++i)
 		{
 			w5100_write(S0_RX_BASE + i, string[upper_size+i]);
@@ -351,5 +346,5 @@
 	else // if not data turn over in RX-mem
 	{
-		for (U08 i = 0; i < NumBytes; ++i)
+		for (U16 i = 0; i < NumBytes; ++i)
 		{
 			w5100_write(start_address + i, string[i]);
@@ -366,2 +361,29 @@
 }
 
+void eth_write_str( U08* str ){
+
+	while (*str) {
+		if (eth_write_index < ETH_WRITE_BUFFER_SIZE) {
+			eth_write_buffer[eth_write_index++] = *str++;
+		}
+		
+	}
+	w5100_set_TX(eth_write_buffer, eth_write_index);
+	eth_write_index = 0;
+}
+
+void eth_writeln_str( U08* str ){
+
+	while (*str) 
+	{
+		if (eth_write_index < ETH_WRITE_BUFFER_SIZE) {
+			eth_write_buffer[eth_write_index++] = *str++;
+		}
+	}
+	if (eth_write_index < ETH_WRITE_BUFFER_SIZE) {
+		eth_write_buffer[eth_write_index++] = '\n';
+	}
+	w5100_set_TX(eth_write_buffer, eth_write_index);
+	eth_write_index = 0;
+}
+
Index: /firmware/FSC/src/w5100_spi_interface.h
===================================================================
--- /firmware/FSC/src/w5100_spi_interface.h	(revision 10909)
+++ /firmware/FSC/src/w5100_spi_interface.h	(revision 10910)
@@ -11,7 +11,8 @@
 
 #define ETH_READ_BUFFER_SIZE 4
-#define ETH_WRITE_BUFFER_SIZE 4
+#define ETH_WRITE_BUFFER_SIZE 32
 extern volatile U08 eth_read_buffer[ETH_READ_BUFFER_SIZE];
 extern volatile U08 eth_write_buffer[ETH_WRITE_BUFFER_SIZE];
+extern U08 eth_write_index;
 //-----------------------------------------------------------------------------
 // Port Definitions
@@ -227,2 +228,4 @@
 
 
+void eth_write_str( U08* str );
+void eth_writeln_str( U08* str );