Programmer_ATM328p/Source/C_Source/prog.c

//Include Header-----------------------------------------------------
#include"prog.h"

/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
//Main-Program
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////

int main(int argc, const char * argv[]){

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//Initializations
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//Setting up Timer-Signal--------------------------------------------
	sigset_t signal;
	pthread_t thread;
	int signal_err, pthread_err;
	signal_err = sigemptyset(&signal);
	if(signal_err!=0){
		error_handler(signal_err, "Not a valid Signal");
	}
	signal_err = sigaddset(&signal, SIGALRM);
	if(signal_err!=0){
		error_handler(signal_err, "Not a valid Signal");
	}
	pthread_err = pthread_sigmask(SIG_BLOCK, &signal, NULL);
	if(pthread_err!=0){
		error_handler(pthread_err, "Error changing Signal-Mask");
	}

//initializing USART at USB_PORT-------------------------------------
	int USB = open("/dev/ttyACM3", O_RDWR|O_NOCTTY|O_NONBLOCK);
	int USB_err = isatty(USB);
	if(USB_err!=1){
		error_handler(USB_err, "No File Descriptor");
	}
	struct termios * termios_ptr = (struct termios *)
									malloc(sizeof(struct termios));
	(*termios_ptr).c_iflag = IGNPAR;			//ignore Parity-Err
	(*termios_ptr).c_oflag = 0;
	(*termios_ptr).c_cflag = CS8|CREAD;			//set Size, enable RX 
	(*termios_ptr).c_lflag = 0;
	(*termios_ptr).c_cc[VMIN] = 0;				//set min Characters
	cfsetspeed(termios_ptr, B19200);			//set Baudrate 19.2k
	tcsetattr(USB, TCSANOW ,termios_ptr);

//initializing Stream for Source-Code--------------------------------
	if(argv[1]==NULL){
		fprintf(stderr, "No File \n");
		exit(EXIT_FAILURE);
	}	
	FILE * file_stream = fopen(argv[1], "r");
	if(file_stream==NULL){
		fprintf(stderr, "No Stream \n");
		exit(EXIT_FAILURE);
	}
	int page_cnt = 0;
	int skip;
	int page_end = page_size;

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//Enable Programming Mode
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	set_timer(0, 100000);							//setting Timer
	pthread_err = pthread_create(&thread, NULL, 
									&signal_thread, (void *)&signal);
	if(pthread_err!=0){
		error_handler(pthread_err, "Failed to create Thread");
	}
	unsigned char * cmd_ack_ptr = (unsigned char *)
												malloc(sizeof(char));
	char * frame_ptr = cmd_build(prog_enable, frame_mask);
reset_1:
	write(USB, frame_ptr, 3*sizeof(char));
	while(true){
		read(USB, cmd_ack_ptr, sizeof(char));
		if(*cmd_ack_ptr==frame_mask){	
			break;
		}
		if(!timer_state){
			printf("\n");
			printf("Connection Timeout \n");
			printf("\n");
			timer_state = true;
			goto reset_1;
		}
	}
	pthread_err = pthread_cancel(thread);
	if(pthread_err!=0){
		error_handler(pthread_err, "Failed to close Thread");
	}
	tcflush(USB, TCIOFLUSH);
	printf("\n");
	printf("Ready for Programming \n");
	printf("\n");
		for(int i=0; i<32; i++){
			printf("-");
		}
		printf("\n");
	free(cmd_ack_ptr);

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//Programming cycle
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	
//Loading and Masking Page-------------------------------------------
	while(page_end==page_size){
		skip=1;
		page_end = page_get(file_stream, page_cnt);
		printf("\n");
		printf("Page %d: \n", page_cnt);
		for(int i=0; i<page_end; i++, skip++){
			printf("%02X", page_buf[i]);
			if(skip==16){
				printf("\n");
				skip=0;
			}
		}
		printf("\n");
		if(skip!=1){
			printf("\n");
		}
		page_cnt++;
		unsigned char * page_ptr = page_mask(&page_buf[0], page_end);

//Opening Connection to Programmer-----------------------------------
		char * cmd_ack_ptr = (char *)malloc(sizeof(char));
		char * frame_ptr = cmd_build(page_read, page_end);
		set_timer(0, 100000);						//setting Timer
		pthread_err = pthread_create(&thread, NULL, 
									&signal_thread, (void *)&signal);
		if(pthread_err!=0){
			error_handler(pthread_err, "Failed to create Thread");
		}
	reset_2:	
		write(USB, frame_ptr, 3*sizeof(char));
		while(true){
			read(USB, cmd_ack_ptr, sizeof(char));
			if(*cmd_ack_ptr==page_end){	
				break;
			}
			if(!timer_state){
				printf("\n");
				printf("Connection Timeout \n");
				printf("\n");
				timer_state = true;
				goto reset_2;
			}
		}
		pthread_err = pthread_cancel(thread);
		if(pthread_err!=0){
			error_handler(pthread_err, "Failed to close Thread");
		}
		tcflush(USB, TCIOFLUSH);
		printf("Ready to Send Page \n");
		free(cmd_ack_ptr);

//Sending Page-------------------------------------------------------
		set_timer(1, 0);							//setting Timer
		pthread_err = pthread_create(&thread, NULL, 
									&signal_thread, (void *)&signal);
		if(pthread_err!=0){
			error_handler(pthread_err, "Failed to create Thread");
		}
	reset_3:									
		write(USB, page_ptr, 2*page_end*sizeof(char));
		unsigned char * page_rec_ptr = (unsigned char *)
												malloc(sizeof(char));
		while(true){
			read(USB, page_rec_ptr, sizeof(char));
			if(*page_rec_ptr==frame_mask){				//Framemask
				break;
			}
			if(!timer_state){
				printf("\n");
				printf("Connection Timeout \n");
				printf("\n");
				timer_state = true;
				goto reset_3;
			}
		}
		pthread_err = pthread_cancel(thread);
		if(pthread_err!=0){
			error_handler(pthread_err, "Failed to close Thread");
		}
		tcflush(USB, TCIOFLUSH);
		printf("Page Send Complete \n");	
		free(page_rec_ptr);

//Receiving Checksum-------------------------------------------------
		printf("\n");
		for(int i=0; i<32; i++){
			printf("-");
		}
		printf("\n");
	}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//Deintialization and Error Handling
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	close(USB);
	return EXIT_SUCCESS;
}

/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
//Sub-Programms
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////

//Signal Thread------------------------------------------------------
void * signal_thread(void * arg_ptr){
	sigset_t * signal_ptr = (sigset_t *)arg_ptr;
	int signal_nr, signal_err;
	while(true){
		signal_err = sigwait(signal_ptr, &signal_nr);
		if(signal_err!=0){
			error_handler(signal_err, "Problem with Signal");
		}
		else if(signal_nr!=SIGALRM){
			fprintf(stderr, "Wrong Signal \n");
		}
		timer_state = false;
	}
	return NULL;
}

//Set Timer----------------------------------------------------------
void set_timer(int sec, int usec){
	struct itimerval timer;
	int timer_err, signal_err;
	timer.it_interval.tv_sec = sec;
	timer.it_interval.tv_usec = usec;
	timer.it_value.tv_sec = sec;
	timer.it_value.tv_usec = usec;
	timer_err = setitimer(ITIMER_REAL, &timer, NULL);
	if(timer_err!=0){
		error_handler(timer_err, "Error setting Timer");
	}
	timer_state = true;
}

//Build Command------------------------------------------------------
char * cmd_build(mode cmd_mode, char cmd_option){
	cmd_t * cmd_ptr = (cmd_t *)malloc(sizeof(cmd_t));
	(*cmd_ptr).mode = frame_mask|cmd_mode;
	(*cmd_ptr).opt_lo = frame_mask|(cmd_option&nibble_lo);
	(*cmd_ptr).opt_hi = frame_mask|((cmd_option>>4)&nibble_lo);
	char * frame_ptr = &((*cmd_ptr).mode);
	return frame_ptr;
}

//Mask Page----------------------------------------------------------
unsigned char * page_mask(char * page_build_ptr, int page_end){
	unsigned char * page_mask_ptr = (unsigned char *)
									malloc(2*page_end*sizeof(char));
	for(int i=0; i<page_end; i++){
		*page_mask_ptr = frame_mask|
								((*page_build_ptr&nibble_hi)>>4);
		*(page_mask_ptr+1) = frame_mask|(*page_build_ptr&nibble_lo);
		page_mask_ptr = page_mask_ptr + 2;
		page_build_ptr++;
	}
	return page_mask_ptr-2*page_end;
}

//Get Page----------------------------------------------------------
int page_get(FILE * input_stream, int p_cnt){
	int j = 0;									//init loc Variables
	int c_cnt = 0;
	if(p_cnt==0){								//check for Start
		for(int k=0; k<9; k++){
			page_buf[0] = fgetc(input_stream);
		}
	}
	else{
		c_cnt = 16;
	}
	while(j<page_size){							//get Char
		page_buf[j] = fgetc(input_stream);
		page_buf[j+1] = fgetc(input_stream);
		if(page_buf[j]==0x25){
			return j;
		}	
		if(c_cnt==16){							//check for Lineend
			c_cnt = 0;
			for(int k=0; k<11; k++){
				page_buf[j] = fgetc(input_stream);
			}
		}
		else{									//Convert to HEX
			for(int m=0; m<2; m++){
				if(page_buf[j+m]<0x3A&&page_buf[j+m]>0x2F){
						page_buf[j+m] -= 0x30;
				}
				else if(page_buf[j+m]<0x47&&page_buf[j+m]>0x40){
						page_buf[j+m] -= 0x37;
				}
			}
			page_buf[j] = ((page_buf[j]<<4)&nibble_hi)|
										(page_buf[j+1]&nibble_lo);
			c_cnt++;
			j++;
		}
	}
	return page_size;
}