gserial.c

本程序是在LINUX下编写的串口程序设计

#include "serialfunc.h"
#include "gserial.h"

#include <gtk/gtk.h>
#include <gdk/gdk.h>
#include <signal.h>
#include <stdio.h>
#include <termios.h>
#include <fcntl.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>


GtkWidget *TV_Info_Display;
GtkWidget *TV_input;
GtkTextIter TV_Info_Disp_Iter;
GtkWidget *entry_input;
GtkWidget *button_send;
GtkWidget *entry_read_count;
GtkWidget *entry_write_count;
GtkWidget *button_open_close_tty;
GtkWidget *button_ignore_unprintable;
GtkWidget *combo_select_tty;
GtkWidget *combo_select_baud;
GtkWidget *combo_select_bits;
GtkWidget *combo_select_check;

GtkWidget *AppWindow;

static gboolean InputHex = FALSE;
static gboolean OutputHex = FALSE;
static gboolean DispPaused = FALSE;
static gboolean IgnoreUnprintable = TRUE;
static gulong ReadCount = 0;
static gulong WriteCount = 0;

void create_tags (GtkTextBuffer * buffer)
{
    g_assert (GTK_IS_TEXT_BUFFER (buffer));
    gtk_text_buffer_create_tag (buffer, "bold","weight", PANGO_WEIGHT_BOLD, NULL);
	gtk_text_buffer_create_tag (buffer, "red-foreground", "foreground", "red",NULL);
}

void CloseTheApp(GtkWidget *window, gpointer data)
{
	if ( tty_get_fp() != NULL )
	{
		tty_serial_close();
	}
	gtk_main_quit();
}

void button_send_clicked(GtkButton *button, gpointer data)
{
	GtkTextBuffer *buffer;
	GtkTextIter start,end;
	gchar *inputdata = NULL;
	gchar aline[MAX_LINE_LENGTH];
	int writenumber;
	int i;
	int lineindex,bitsindex;
	gboolean blankfinded;
	guchar tempchar,tempbit;
	
	buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(TV_input));
	gtk_text_buffer_get_iter_at_offset(buffer,&start,0);
	gtk_text_buffer_get_iter_at_offset(buffer,&end,-1);
	inputdata = gtk_text_buffer_get_text(buffer,&start,&end,FALSE);

	if (InputHex)
	{
		lineindex = 0;
		bitsindex = 0;
		
		for( i = 0;i<strlen(inputdata);i++)
		{
			
			if( isxdigit(inputdata[i]) )
			{
				if( (inputdata[i]>='0') && (inputdata[i]<='9') )
					tempbit = inputdata[i] - '0';
				else
					tempbit = tolower(inputdata[i]) - 'a' + 10;
				
				if(bitsindex == 0)
				{
					tempchar = tempbit * 16;
					bitsindex = 1;
				}
				else
				{
					tempchar += tempbit;
					bitsindex = 0;
					aline[lineindex++] = tempchar;
					if(lineindex == (MAX_LINE_LENGTH-1))
					{
						aline[lineindex] = '\0';
						if ( (writenumber = tty_write_data(aline)) != EOF )
						{
							WriteCount += writenumber;
							update_write_count(WriteCount);
						}
						lineindex = 0;
					}
				}
			}
			else
			{
				bitsindex = 0;
			}
		}
		aline[lineindex] = '\0';
		if ( (writenumber = tty_write_data(aline)) != EOF )
		{
			WriteCount += writenumber;
			update_write_count(WriteCount);
		}
	}
	else
	{
		if ( (writenumber = tty_write_data(inputdata)) != EOF )
		{
			WriteCount += writenumber;
			update_write_count(WriteCount);
		}
	}
	
	if( inputdata != NULL )
	{
		g_free(inputdata);
		inputdata = NULL;
	}
	
}
int SaveDispData(const gchar* filename)
{
	FILE* fp = NULL;
	char *data;
	GtkTextBuffer *buffer;
	GtkTextIter start;
	GtkTextIter end;
	GtkWidget *message_dlg;
	gint return_value;
	
	if ((fp = fopen(filename,"r")) != NULL)
	{
		fclose(fp);
		message_dlg = gtk_message_dialog_new(GTK_WINDOW(AppWindow),GTK_DIALOG_MODAL,
				GTK_MESSAGE_QUESTION,GTK_BUTTONS_YES_NO,"确定要覆盖文件?");
		return_value = gtk_dialog_run(GTK_DIALOG(message_dlg));
		gtk_widget_destroy(message_dlg);
		if( return_value != GTK_RESPONSE_YES)
			return -2;
	}
	if ((fp = fopen(filename,"w")) == NULL)
	{
		g_warning("error open %s\n",filename);
		return -1;
	}
	
	buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(TV_Info_Display));
	gtk_text_buffer_get_iter_at_offset(buffer,&start,0);
	gtk_text_buffer_get_iter_at_offset(buffer,&end,-1);
	
	data = gtk_text_buffer_get_text(buffer,&start,&end,FALSE);
	fputs(data,fp);
	fclose(fp);
	free(data);
	data = NULL;

	return 0;

}

void SaveFileDlg_OK_Clicked(GtkButton *button,gpointer filedlg)
{
	G_CONST_RETURN gchar * SelectedFile;
	gchar *filename;
	
	SelectedFile = gtk_file_selection_get_filename(GTK_FILE_SELECTION(filedlg));
	
	filename = strdup(rindex(SelectedFile,'/')+1);
	
	if ( strlen(filename) == 0)
	{
		g_warning("no filename input\n");
		gtk_widget_destroy(GTK_WIDGET(filedlg));
		return;
	}

	SaveDispData(SelectedFile);
		
	free(filename);
	filename = NULL;
	gtk_widget_destroy(GTK_WIDGET(filedlg));
}

void SaveFileDlg_Cancel_Clicked(GtkButton *button,gpointer filedlg)
{
	gchar * SelectedFile;

	gtk_widget_destroy(GTK_WIDGET(filedlg));
}


int ReadInputData(const gchar* filename)
{
	FILE* fp = NULL;
	GtkTextBuffer *buffer;
	gchar data[MAX_LINE_LENGTH];
	gchar dispdata[MAX_LINE_LENGTH * 3];
	gchar achar[3];
	gsize readcount,totalcount;
	gint i,j;
	GtkTextIter iter;
	
	if ((fp = fopen(filename,"r")) == NULL)
	{
		g_warning("error open %s\n",filename);
		return -1;
	}
	
	buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(TV_input));
	gtk_text_buffer_set_text(buffer,"",0);

	totalcount = 0;
	while (!feof(fp))
	{
		readcount = fread(data,sizeof(char),MAX_LINE_LENGTH-1,fp);
		totalcount += readcount;
		j=0;
		if (InputHex)
		{
			for(i=0;i<readcount;i++)
			{
				sprintf(achar,"%02X",data[i]);
				dispdata[j++] = achar[0];
				dispdata[j++] = achar[1];
				dispdata[j++] = ' ';
			}
		}
		else
		{
			for(i=0;i<readcount;i++)
			{
				//	Judge if the char is printable or is the \r\n char
				if ( isprint(data[i]) || (data[i] == 0x0A) || (data[i] == 0x0D) )
				{
					dispdata[j++] = data[i];
				}
			}
		}
		dispdata[j] = '\0';
		gtk_text_buffer_get_iter_at_offset(buffer,&iter,-1);
		gtk_text_buffer_insert(buffer,&iter,dispdata,-1);
		gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(TV_input),
				&iter,0.0,FALSE,0.0,1.0);
	}
	
	fclose(fp);
	return 0;
}

void OpenFileDlg_OK_Clicked(GtkButton *button,gpointer filedlg)
{
	G_CONST_RETURN gchar * SelectedFile;
	
	SelectedFile = gtk_file_selection_get_filename(GTK_FILE_SELECTION(filedlg));
	
	ReadInputData(SelectedFile);
		
	gtk_widget_destroy(GTK_WIDGET(filedlg));
}

void OpenFileDlg_Cancel_Clicked(GtkButton *button,gpointer filedlg)
{
	gchar * SelectedFile;

	gtk_widget_destroy(GTK_WIDGET(filedlg));
}

void button_read_clicked(GtkButton *button, gpointer data)
{

	GtkWidget *openfiledlg;

	openfiledlg = gtk_file_selection_new("选择要读取的文件");

	gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(openfiledlg)->ok_button),
				"clicked",GTK_SIGNAL_FUNC(OpenFileDlg_OK_Clicked),openfiledlg);


	gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(openfiledlg)->cancel_button),
				"clicked",GTK_SIGNAL_FUNC(OpenFileDlg_Cancel_Clicked),openfiledlg);

	gtk_window_set_modal(GTK_WINDOW(openfiledlg),TRUE);
	gtk_widget_show(openfiledlg);

}

void button_save_clicked(GtkButton *button, gpointer data)
{
	GtkWidget *savefiledlg;

	savefiledlg = gtk_file_selection_new("输入文件名");

	gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(savefiledlg)->ok_button),
				"clicked",GTK_SIGNAL_FUNC(SaveFileDlg_OK_Clicked),savefiledlg);


	gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(savefiledlg)->cancel_button),
				"clicked",GTK_SIGNAL_FUNC(SaveFileDlg_Cancel_Clicked),savefiledlg);

	gtk_window_set_modal(GTK_WINDOW(savefiledlg),TRUE);
	gtk_widget_show(savefiledlg);

}

void update_read_count(gulong n)
{
	char tempdata[15];
	sprintf(tempdata,"%lu",n);
	gtk_entry_set_text(GTK_ENTRY(entry_read_count),tempdata);
}

void update_write_count(gulong n)
{
	char tempdata[15];
	sprintf(tempdata,"%lu",n);
	gtk_entry_set_text(GTK_ENTRY(entry_write_count),tempdata);
}

void button_clear_read_count_clicked(GtkButton *button, gpointer data)
{
	ReadCount = 0;
	update_read_count(ReadCount);
}

void button_clear_write_count_clicked(GtkButton *button, gpointer data)
{
	WriteCount = 0;
	update_write_count(WriteCount);
}

void button_clear_input_clicked(GtkButton *button, gpointer data)
{

	gtk_text_buffer_set_text(
			gtk_text_view_get_buffer(GTK_TEXT_VIEW(TV_input)),"",0);

}

void button_clear_output_clicked(GtkButton *button, gpointer data)
{
	
	gtk_text_buffer_set_text(
			gtk_text_view_get_buffer(GTK_TEXT_VIEW(TV_Info_Display)),"",0);

}
void button_open_close_tty_clicked(GtkButton *button, gpointer data)
{
	static gboolean opened = FALSE;
	static guint input_handle;

	if( opened )
	{
		gtk_input_remove(input_handle);
		tty_serial_close();
		gtk_button_set_label(button,"打开串口");
		opened = FALSE;
	}
	else
	{
		if( tty_serial_open() == 0 )
		{
			
			input_handle = gtk_input_add_full(fileno(tty_get_fp()),
					GDK_INPUT_READ,readserial,NULL,NULL,NULL);
			gtk_button_set_label(button,"关闭串口");
			opened = TRUE;
		}
	}

}

void button_input_hex_toggled(GtkToggleButton *button,gpointer data)
{
	InputHex = gtk_toggle_button_get_active(button);
}

void button_output_hex_toggled(GtkToggleButton *button,gpointer data)
{

	OutputHex = gtk_toggle_button_get_active(button);
	gtk_widget_set_sensitive(button_ignore_unprintable,!OutputHex);

}

void button_ignore_unprintable_toggled(GtkToggleButton *button,gpointer data)
{

	IgnoreUnprintable = gtk_toggle_button_get_active(button);
}

void button_pause_clicked(GtkButton *button,gpointer data)
{
	if( DispPaused )
	{
		gtk_button_set_label(button,"暂停");
		DispPaused = FALSE;	
	}
	else
	{
		gtk_button_set_label(button,"显示");
		DispPaused = TRUE;
	}

}

void combo_select_tty_selectchild(GtkList *list,GtkWidget *child,gpointer data)
{
	static gint lastindex=-1;
	gint index;

	g_assert( (index = gtk_list_child_position(list,child)) != -1);
	if( index != lastindex )
	{
		switch(index)
		{
			case 0:
				tty_set_port("/dev/ttyS0");
				break;
			case 1:
				tty_set_port("/dev/ttyS1");
				break;
			case 2:
				tty_set_port("/dev/ttyS2");
				break;
			case 3:
				tty_set_port("/dev/ttyS3");
				break;
			default:
				g_warning("should no come here\n");
				break;
		}
		
		lastindex = index;
	}
}
void combo_select_baud_selectchild(GtkList *list,GtkWidget *child,gpointer data)
{
	static gint lastindex=-1;
	gint index;

	g_assert( (index = gtk_list_child_position(list,child)) != -1);
	if( index != lastindex )
	{
		switch(index)
		{
			case 0:
				tty_set_baud_rate(B300);
				break;
			case 1:
				tty_set_baud_rate(B600);