Added SMSD non-interactive command line client for Shack-Hartmann control system

Trinamic/SHA_client_cmdline/Makefile

@@ -0,0 +1,22 @@
+PROGRAM = client
+LDFLAGS =
+SRCS = client.c parceargs.c cmdlnopts.c
+CC = gcc
+DEFINES = -D_XOPEN_SOURCE=701
+CXX = gcc
+CFLAGS = -Wall -Werror $(DEFINES)
+OBJS = $(SRCS:.c=.o)
+all : $(PROGRAM) clean
+$(PROGRAM) : $(OBJS)
+	$(CC) $(CFLAGS) $(OBJS) $(LDFLAGS) -o $(PROGRAM)
+
+# some addition dependencies
+# %.o: %.c
+#        $(CC) $(LDFLAGS) $(CFLAGS) $< -o $@
+#$(SRCS) : %.c : %.h $(INDEPENDENT_HEADERS)
+#        @touch $@
+
+clean:
+	/bin/rm -f *.o *~
+depend:
+	$(CXX) -MM $(CXX.SRCS)

Trinamic/SHA_client_cmdline/client.c

@@ -0,0 +1,405 @@
+/*
+ * client.c - simple terminal client for operationg with
+ * Standa's 8MT175-150 translator by SMSD-1.5 driver
+ *
+ * Hardware operates in microsterpping mode (1/16),
+ * max current = 1.2A
+ * voltage     = 12V
+ * "0" of driver connected to end-switch at opposite from motor side
+ * switch of motor's side connected to "IN1"
+ *
+ * Copyright 2013 Edward V. Emelianoff <eddy@sao.ru>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#include <termios.h>		// tcsetattr
+#include <unistd.h>			// tcsetattr, close, read, write
+#include <sys/ioctl.h>		// ioctl
+#include <stdio.h>			// printf, getchar, fopen, perror
+#include <stdlib.h>			// exit
+#include <sys/stat.h>		// read
+#include <fcntl.h>			// read
+#include <signal.h>			// signal
+#include <time.h>			// time
+#include <string.h>			// memcpy, strcmp etc
+#include <strings.h>		// strcasecmp
+#include <stdint.h>			// int types
+#include <sys/time.h>		// gettimeofday
+#include "cmdlnopts.h"
+
+#define DBG(...) do{fprintf(stderr, __VA_ARGS__); }while(0)
+
+//double t0; // start time
+static int bus_error = 0; // last error of data output
+enum{
+	NO_ERROR  = 0, // normal execution
+	CODE_ERR,      // error of exexuted program code
+	BUS_ERR,       // data transmission error
+	COMMAND_ERR,   // wrong command
+	CMD_DATA_ERR,  // wrong data of command
+	UNDEFINED_ERR  // something else wrong
+};
+
+int BAUD_RATE = B9600;
+uint16_t step_spd = 900;  // stepper speed: 225 steps per second in 1/1 mode
+struct termio oldtty, tty; // TTY flags
+int comfd = -1; // TTY fd
+
+int erase_ctrlr();
+
+/**
+ * Exit & return terminal to old state
+ * @param ex_stat - status (return code)
+ */
+void quit(int ex_stat){
+	if(comfd > 0){
+		erase_ctrlr();
+		ioctl(comfd, TCSANOW, &oldtty ); // return TTY to previous state
+		close(comfd);
+	}
+	printf("Exit! (%d)\n", ex_stat);
+	exit(ex_stat);
+}
+
+/**
+ * Open & setup TTY, terminal
+ */
+void tty_init(){
+	printf("\nOpen port...\n");
+	if ((comfd = open(G.comdev,O_RDWR|O_NOCTTY|O_NONBLOCK)) < 0){
+		fprintf(stderr,"Can't use port %s\n", G.comdev);
+		quit(1);
+	}
+	printf(" OK\nGet current settings...\n");
+	if(ioctl(comfd,TCGETA,&oldtty) < 0) quit(-1); // Get settings
+	tty = oldtty;
+	tty.c_lflag     = 0; // ~(ICANON | ECHO | ECHOE | ISIG)
+	tty.c_oflag     = 0;
+	tty.c_cflag     = BAUD_RATE|CS8|CREAD|CLOCAL | PARENB; // 9.6k, 8N1, RW, ignore line ctrl
+	tty.c_cc[VMIN]  = 0;  // non-canonical mode
+	tty.c_cc[VTIME] = 5;
+	if(ioctl(comfd,TCSETA,&tty) < 0) quit(-1); // set new mode
+	printf(" OK\n");
+}
+
+/**
+ * Read data from TTY
+ * @param buff (o) - buffer for data read
+ * @param length   - buffer len
+ * @return amount of readed bytes
+ */
+size_t read_tty(char *buff, size_t length){
+	ssize_t L = 0;
+	fd_set rfds;
+	struct timeval tv;
+	int retval;
+	FD_ZERO(&rfds);
+	FD_SET(comfd, &rfds);
+	tv.tv_sec = 0; tv.tv_usec = 50000;
+	retval = select(comfd + 1, &rfds, NULL, NULL, &tv);
+	if(retval < 1) return 0;
+	if(FD_ISSET(comfd, &rfds)){
+		if((L = read(comfd, buff, length)) < 1){
+			fprintf(stderr, "ERROR on bus, exit!\n");
+			quit(-4);
+		}
+	}
+	return (size_t)L;
+}
+
+void write_tty(char *str, int L){
+	ssize_t D = write(comfd, str, L);
+	if(D != L){
+		fprintf(stderr, "ERROR on bus, exit!\n");
+		quit(-3);
+	}
+}
+
+size_t read_ctrl_command(char *buf, size_t L){ // read data from controller to buffer buf
+	int i, j;
+	char *ptr = buf;
+	size_t R;
+	memset(buf, 0, L);
+	for(j = 0; j < L; j++, ptr++){
+		R = 0;
+		for(i = 0; i < 10 && !R; i++){
+			R = read_tty(ptr, 1);
+		}
+		if(!R){j--; break;}  // nothing to read
+		if(*ptr == '*') // read only one command
+			break;
+		if(*ptr < ' '){ // omit spaces & non-characters
+			j--; ptr--;
+		}
+	}
+	return (size_t) j + 1;
+}
+
+int parse_ctrlr_ans(char *ans){
+	char *E = NULL, *Star = NULL;
+	if(!ans || !*ans) return 1;
+	bus_error = NO_ERROR;
+	if(!(E = strchr(ans, 'E')) || !(Star = strchr(ans, '*')) || E[1] != '1'){
+		fprintf(stderr, "Answer format error (got: %s)\n", ans);
+		bus_error = UNDEFINED_ERR;
+		return 0;
+	}
+	switch (E[2]){ // E = "E1x"
+		case '0': // 10 - normal execution
+		break;
+		case '4': // 14 - program end
+			printf("Last command exectuted normally\n");
+		break;
+		case '2': // command interrupt by other signal
+			fprintf(stderr, "Last command terminated\n");
+		break;
+		case '3':
+			bus_error = CODE_ERR;
+			fprintf(stderr, "runtime");
+		break;
+		case '5':
+			bus_error = BUS_ERR;
+			fprintf(stderr, "data bus");
+		break;
+		case '6':
+			bus_error = COMMAND_ERR;
+			fprintf(stderr, "command");
+		break;
+		case '9':
+			bus_error = CMD_DATA_ERR;
+			fprintf(stderr, "command data");
+		break;
+		default:
+			bus_error = UNDEFINED_ERR;
+			fprintf(stderr, "undefined (%s)", ans);
+	}
+	if(bus_error != NO_ERROR){
+		fprintf(stderr, " error in controller\n");
+		return 0;
+	}
+	return 1;
+}
+
+int send_command(char *cmd){
+	int L = strlen(cmd);
+	size_t R = 0;
+	char ans[256];
+	write_tty(cmd, L);
+	R = read_ctrl_command(ans, 255);
+//	DBG("readed: %s (cmd: %s, R = %zd, L = %d)\n", ans, cmd, R, L);
+	if(!R || (strncmp(ans, cmd, L) != 0)){
+		fprintf(stderr, "Error: controller doesn't respond (answer: %s)\n", ans);
+		return 0;
+	}
+	R = read_ctrl_command(ans, 255);
+//	DBG("readed: %s\n", ans);
+	if(!R){ // controller is running or error
+		fprintf(stderr, "Controller doesn't answer!\n");
+		return 0;
+	}
+	return parse_ctrlr_ans(ans);
+}
+
+int erase_ctrlr(){
+	char *errmsg = "\n\nCan't erase controller's memory: some errors occured!\n\n";
+	printf("Erasing old program\n");
+	#define safely_send(x) do{ if(bus_error != NO_ERROR){				\
+		fprintf(stderr, errmsg); return 0;} send_command(x); }while(0)
+	if(!send_command("LD1*")){ // start writing a program
+	//if(!send_command("LB*")){ // start writing a program into op-buffer
+		if(bus_error == COMMAND_ERR){ // motor is moving
+			printf("Found running program, stop it\n");
+			if(!send_command("ST1*"))
+			//if(!send_command("ST*"))
+				send_command("SP*");
+			send_command("LD1*");
+			//send_command("LB*");
+		}else{
+			fprintf(stderr, "Controller doesn't answer: maybe no power?\n");
+			return 1;
+		}
+	}
+	safely_send("BG*");   // move address pointer to beginning
+	safely_send("DS*");   // turn off motor
+	safely_send("ED*");   // end of program
+	if(bus_error != NO_ERROR){
+		fprintf(stderr, errmsg);
+		return 0;
+	}
+	return 1;
+}
+
+int con_sig(int rb, int stepsN){
+	int got_command = 0;
+	char command[256];
+	char buf[13];
+	#define Die_on_error(arg) do{if(!send_command(arg)) goto erase_;}while(0)
+	if(strchr("-+01Rr", rb)){ // command to execute
+		got_command = 1;
+		if(!send_command("LD1*")){        // start writing a program
+		//if(!send_command("LB*")){        // start writing a program into op-buffer
+			fprintf(stderr, "Error: previous program is running!\n");
+			return 0;
+		}
+		Die_on_error("BG*");              // move address pointer to beginning
+		if(strchr("-+01", rb)){
+			Die_on_error("EN*");              // enable power
+			//Die_on_error("SD10000*");         // set speed to max (156.25 steps per second with 1/16)
+			snprintf(buf, 12, "SD%u*", step_spd);
+			Die_on_error(buf);
+		}
+	}
+	switch(rb){
+		case '0':
+			Die_on_error("DL*");
+			Die_on_error("HM*");
+		break;
+		case '1':
+			Die_on_error("DR*");
+			Die_on_error("ML*");
+		break;
+		case '+':
+			Die_on_error("DR*");
+			if(stepsN)
+				sprintf(command, "MV%d*", stepsN);
+			else
+				sprintf(command, "MV*");
+			Die_on_error(command);
+		break;
+		case '-':
+			Die_on_error("DL*");
+			if(stepsN)
+				sprintf(command, "MV%d*", stepsN);
+			else
+				sprintf(command, "MV*");
+			Die_on_error(command);
+		break;
+		case 'S':
+			Die_on_error("SP*");
+		break;
+		case 'A':
+			Die_on_error("ST1*");
+			//Die_on_error("ST*");
+		break;
+		case 'E':
+			erase_ctrlr();
+		break;
+		case 'R':
+			Die_on_error("SF*");
+		break;
+		case 'r':
+			Die_on_error("CF*");
+		break;
+		case '>': // increase speed for 25 pulses
+			step_spd += 25;
+			printf("\nCurrent speed: %u pulses per sec\n", step_spd);
+			//snprintf(buf, 12, "SD%u*", step_spd);
+			//Die_on_error(buf);
+		break;
+		case '<': // decrease speed for 25 pulses
+			if(step_spd > 25){
+				step_spd -= 25;
+				printf("\nCurrent speed: %u pulses per sec\n", step_spd);
+				//snprintf(buf, 12, "SD%u*", step_spd);
+				//Die_on_error(buf);
+			}else
+				printf("\nSpeed is too low\n");
+		break;
+
+	}
+	if(got_command){ // there was some command: write ending words
+		Die_on_error("DS*"); // turn off power from motor at end
+		Die_on_error("ED*"); // signal about command end
+		Die_on_error("ST1*");// start program
+		return 1;
+	}
+	return 0;
+erase_:
+	erase_ctrlr();
+	return 0;
+}
+
+void wait_for_answer(){
+	char buff[128], *bufptr = buff;
+	size_t L;
+	while(1){
+		L = read_tty(bufptr, 127);
+		if(L){
+			bufptr += L;
+			if(bufptr - buff > 127){
+				fprintf(stderr, "Error: input buffer overflow!\n");
+				bufptr = buff;
+			}
+			if(bufptr[-1] == '*'){ // end of input command
+				*bufptr = 0;
+				parse_ctrlr_ans(buff);
+				return;
+			}
+		}
+	}
+}
+
+int main(int argc, char *argv[]){
+	parce_args(argc, argv);
+	tty_init();
+	signal(SIGTERM, quit);		// kill (-15)
+	signal(SIGINT,  quit);		// ctrl+C
+	signal(SIGQUIT, SIG_IGN);	// ctrl+\   .
+	signal(SIGTSTP, SIG_IGN);	// ctrl+Z
+	setbuf(stdout, NULL);
+	erase_ctrlr();
+	if(G.erasecmd) return 0;
+	if(G.relaycmd == -1 && G.gotopos == NULL){
+		printf("No commands given!\n");
+		return -1;
+	}
+	if(G.relaycmd != -1){
+		int ans;
+		if(G.relaycmd) // turn on
+			ans = con_sig('R',0);
+		else // turn off
+			ans = con_sig('r',0);
+		if(ans)
+			wait_for_answer();
+		else
+			return -1;
+	}
+	if(G.gotopos){
+		if(strcasecmp(G.gotopos, "refmir") == 0){
+			if(!con_sig('1',0)) return -1;
+			printf("Go to last end-switch\n");
+			wait_for_answer();
+			if(!con_sig('-',500)) return -1;
+		}else if(strcasecmp(G.gotopos, "diagmir") == 0){
+			if(!con_sig('0',0)) return -1;
+			printf("Go to zero's end-switch\n");
+			wait_for_answer();
+			if(!con_sig('+',2500)) return -1;
+		}else if(strcasecmp(G.gotopos, "shack") == 0){
+			if(!con_sig('1',0)) return -1;
+			printf("Go to last end-switch\n");
+			wait_for_answer();
+			if(!con_sig('-',30000)) return -1;
+		}else{
+			printf("Wrong goto command, should be one of refmir/diagmir/shack\n");
+			return -1;
+		}
+		printf("Go to position\n");
+		wait_for_answer();
+	}
+	return 0;
+}

Trinamic/SHA_client_cmdline/cmdlnopts.c

@@ -0,0 +1,84 @@
+/*
+ * cmdlnopts.c - the only function that parce cmdln args and returns glob parameters
+ *
+ * Copyright 2013 Edward V. Emelianoff <eddy@sao.ru>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#include "cmdlnopts.h"
+
+/*
+ * here are global parameters initialisation
+ */
+glob_pars G;  // internal global parameters structure
+int help = 0; // whether to show help string
+
+glob_pars Gdefault = {
+	.comdev    = "/dev/ttyUSB0",
+	.relaycmd  = -1,
+	.erasecmd  = 0,
+	.gotopos   = NULL
+};
+
+/*
+ * Define command line options by filling structure:
+ *	name	has_arg	flag	val		type		argptr			help
+*/
+myoption cmdlnopts[] = {
+	/// "ÏÔÏÂÒÁÚÉÔØ ÜÔÏ ÓÏÏÂÝÅÎÉÅ"
+	{"help",	0,	NULL,	'h',	arg_int,	APTR(&help),		"show this help"},
+	/// "ÐÕÔØ Ë ÕÓÔÒÏÊÓÔ×Õ"
+	{"comdev",1,	NULL,	'd',	arg_string,	APTR(&G.comdev),	"input device path"},
+	/// "×ËÌÀÞÉÔØ (1)/×ÙËÌÀÞÉÔØ (0) ÒÅÌÅ"
+	{"relay", 1,	NULL,	'r',	arg_int,	APTR(&G.relaycmd),	"turn relay on (1)/off (0)"},
+	/// "ÔÏÌØËÏ ÏÞÉÓÔÉÔØ ÐÁÍÑÔØ ËÏÎÔÒÏÌÌÅÒÁ"
+	{"erase-old",0,NULL,	'e',	arg_none,	APTR(&G.erasecmd),	"only erase controller's memory"},
+	/// "ÐÅÒÅÊÔÉ ÎÁ ÐÏÚÉÃÉÀ (refmir/diagmir/shack)"
+	{"goto", 1,		NULL,	'g',	arg_string,	APTR(&G.gotopos),	"go to position (refmir/diagmir/shack)"},
+	// ...
+	end_option
+};
+
+/**
+ * Parce command line options and return dynamically allocated structure
+ * 		to global parameters
+ * @param argc - copy of argc from main
+ * @param argv - copy of argv from main
+ * @return allocated structure with global parameters
+ */
+glob_pars *parce_args(int argc, char **argv){
+	int i;
+	void *ptr;
+	ptr = memcpy(&G, &Gdefault, sizeof(G)); assert(ptr);
+	// format of help: "Usage: progname [args]\n"
+	/// "éÓÐÏÌØÚÏ×ÁÎÉÅ: %s [ÁÒÇÕÍÅÎÔÙ]\n\n\tçÄÅ ÁÒÇÕÍÅÎÔÙ:\n"
+	change_helpstring("Usage: %s [args]\n\n\tWhere args are:\n");
+	// parse arguments
+	parceargs(&argc, &argv, cmdlnopts);
+	if(help) showhelp(-1, cmdlnopts);
+	if(argc > 0){
+		/// "éÇÎÏÒÉÒÕÀ ÁÒÇÕÍÅÎÔ[Ù]:"
+		printf("\n%s\n", "Ignore argument[s]:");
+		for (i = 0; i < argc; i++)
+			printf("\t%s\n", argv[i]);
+	}
+	return &G;
+}
+

Trinamic/SHA_client_cmdline/cmdlnopts.h

@@ -0,0 +1,43 @@
+/*
+ * cmdlnopts.h - comand line options for parceargs
+ *
+ * Copyright 2013 Edward V. Emelianoff <eddy@sao.ru>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#pragma once
+#ifndef __CMDLNOPTS_H__
+#define __CMDLNOPTS_H__
+
+#include "parceargs.h"
+
+/*
+ * here are some typedef's for global data
+ */
+
+typedef struct{
+	char *comdev;           // input device
+	int relaycmd;           // -1 - nothing, 1 - on, 0 - off
+	int erasecmd;           // 1 to erase old
+	char *gotopos;          // position name: refmir, diagmir, shack
+}glob_pars;
+
+extern glob_pars G;
+
+glob_pars *parce_args(int argc, char **argv);
+
+#endif // __CMDLNOPTS_H__

Trinamic/SHA_client_cmdline/parceargs.c

@@ -0,0 +1,314 @@
+/*
+ * parceargs.c - parcing command line arguments & print help
+ *
+ * Copyright 2013 Edward V. Emelianoff <eddy@sao.ru>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#include <stdio.h>	// DBG
+#include <getopt.h>	// getopt_long
+#include <stdlib.h>	// calloc, exit, strtoll
+#include <assert.h>	// assert
+#include <string.h> // strdup, strchr, strlen
+#include <limits.h> // INT_MAX & so on
+#include <libintl.h>// gettext
+#include <ctype.h>	// isalpha
+#include "parceargs.h"
+
+#define DBG(...)
+
+// macro to print help messages
+#ifndef PRNT
+	#define PRNT(x) gettext(x)
+#endif
+
+char *helpstring = "%s\n";
+
+/**
+ * Change standard help header
+ * MAY consist ONE "%s" for progname
+ * @param str (i) - new format
+ */
+void change_helpstring(char *s){
+	int pcount = 0, scount = 0;
+	char *str = s;
+	// check `helpstring` and set it to default in case of error
+	for(; pcount < 2; str += 2){
+		if(!(str = strchr(str, '%'))) break;
+		if(str[1] != '%') pcount++; // increment '%' counter if it isn't "%%"
+		else{
+			str += 2; // pass next '%'
+			continue;
+		}
+		if(str[1] == 's') scount++; // increment "%s" counter
+	};
+	DBG("pc: %d, sc: %d\n", pcount, scount);
+	if(pcount > 1 || pcount != scount){ // amount of pcount and/or scount wrong
+		fprintf(stderr, "Wrong helpstring!\n");
+		exit(-1);
+	}
+	helpstring = s;
+	DBG("hs: %s\n", helpstring);
+}
+
+/**
+ * Carefull atoll/atoi
+ * @param num (o) - returning value (or NULL if you wish only check number) - allocated by user
+ * @param str (i) - string with number must not be NULL
+ * @param t   (i) - T_INT for integer or T_LLONG for long long (if argtype would be wided, may add more)
+ * @return TRUE if conversion sone without errors, FALSE otherwise
+ */
+bool myatoll(void *num, char *str, argtype t){
+	long long tmp, *llptr;
+	int *iptr;
+	char *endptr;
+	assert(str);
+	assert(num);
+	tmp = strtoll(str, &endptr, 0);
+	if(endptr == str || *str == '\0' || *endptr != '\0')
+		return FALSE;
+	switch(t){
+		case arg_longlong:
+			llptr = (long long*) num;
+			*llptr = tmp;
+		break;
+		case arg_int:
+		default:
+			if(tmp < INT_MIN || tmp > INT_MAX){
+				fprintf(stderr, "Integer out of range\n");
+				return FALSE;
+			}
+			iptr = (int*)num;
+			*iptr = (int)tmp;
+	}
+	return TRUE;
+}
+
+// the same as myatoll but for double
+// There's no NAN & INF checking here (what if they would be needed?)
+bool myatod(void *num, const char *str, argtype t){
+	double tmp, *dptr;
+	float *fptr;
+	char *endptr;
+	assert(str);
+	tmp = strtod(str, &endptr);
+	if(endptr == str || *str == '\0' || *endptr != '\0')
+		return FALSE;
+	switch(t){
+		case arg_double:
+			dptr = (double *) num;
+			*dptr = tmp;
+		break;
+		case arg_float:
+		default:
+			fptr = (float *) num;
+			*fptr = (float)tmp;
+		break;
+	}
+	return TRUE;
+}
+
+/**
+ * Get index of current option in array options
+ * @param opt (i) - returning val of getopt_long
+ * @param options (i) - array of options
+ * @return index in array
+ */
+int get_optind(int opt, myoption *options){
+	int oind;
+	myoption *opts = options;
+	assert(opts);
+	for(oind = 0; opts->name && opts->val != opt; oind++, opts++);
+	if(!opts->name || opts->val != opt) // no such parameter
+	showhelp(-1, options);
+	return oind;
+}
+
+/**
+ * Parce command line arguments
+ * ! If arg is string, then value will be strdup'ed!
+ *
+ * @param argc (io) - address of argc of main(), return value of argc stay after `getopt`
+ * @param argv (io) - address of argv of main(), return pointer to argv stay after `getopt`
+ * BE CAREFUL! if you wanna use full argc & argv, save their original values before
+ * 		calling this function
+ * @param options (i) - array of `myoption` for arguments parcing
+ *
+ * @exit: in case of error this function show help & make `exit(-1)`
+  */
+void parceargs(int *argc, char ***argv, myoption *options){
+	char *short_options, *soptr;
+	struct option *long_options, *loptr;
+	size_t optsize, i;
+	myoption *opts = options;
+	// check whether there is at least one options
+	assert(opts);
+	assert(opts[0].name);
+	// first we count how much values are in opts
+	for(optsize = 0; opts->name; optsize++, opts++);
+	// now we can allocate memory
+	short_options = calloc(optsize * 3 + 1, 1); // multiply by three for '::' in case of args in opts
+	long_options = calloc(optsize + 1, sizeof(struct option));
+	opts = options; loptr = long_options; soptr = short_options;
+	// fill short/long parameters and make a simple checking
+	for(i = 0; i < optsize; i++, loptr++, opts++){
+		// check
+		assert(opts->name); // check name
+		if(opts->has_arg){
+			assert(opts->type != arg_none); // check error with arg type
+			assert(opts->argptr);  // check pointer
+		}
+		if(opts->type != arg_none) // if there is a flag without arg, check its pointer
+			assert(opts->argptr);
+		// fill long_options
+		// don't do memcmp: what if there would be different alignment?
+		loptr->name		= opts->name;
+		loptr->has_arg	= opts->has_arg;
+		loptr->flag		= opts->flag;
+		loptr->val		= opts->val;
+		// fill short options if they are:
+		if(!opts->flag){
+			*soptr++ = opts->val;
+			if(opts->has_arg) // add ':' if option has required argument
+				*soptr++ = ':';
+			if(opts->has_arg == 2) // add '::' if option has optional argument
+				*soptr++ = ':';
+		}
+	}
+	// now we have both long_options & short_options and can parse `getopt_long`
+	while(1){
+		int opt;
+		int oindex = 0, optind = 0; // oindex - number of option in argv, optind - number in options[]
+		if((opt = getopt_long(*argc, *argv, short_options, long_options, &oindex)) == -1) break;
+		if(opt == '?'){
+			opt = optopt;
+			optind = get_optind(opt, options);
+			if(options[optind].has_arg == 1) showhelp(optind, options); // need argument
+		}
+		else{
+			if(opt == 0 || oindex > 0) optind = oindex;
+			else optind = get_optind(opt, options);
+		}
+		opts = &options[optind];
+#ifdef EBUG
+DBG ("\n*******\noption %s (oindex = %d / optind = %d)", options[optind].name, oindex, optind);
+if(optarg) DBG (" with arg %s", optarg);
+DBG ("\n");
+#endif
+		if(opt == 0 && opts->has_arg == 0) continue; // only long option changing integer flag
+DBG("opt = %c, arg type: ", opt);
+		// now check option
+		if(opts->has_arg == 1) assert(optarg);
+		bool result = TRUE;
+		// even if there is no argument, but argptr != NULL, think that optarg = "1"
+		if(!optarg) optarg = "1";
+		switch(opts->type){
+			default:
+			case arg_none:
+DBG("none\n");
+				if(opts->argptr) *((int*)opts->argptr) = 1; // set argptr to 1
+			break;
+			case arg_int:
+DBG("integer\n");
+				result = myatoll(opts->argptr, optarg, arg_int);
+			break;
+			case arg_longlong:
+DBG("long long\n");
+				result = myatoll(opts->argptr, optarg, arg_longlong);
+			break;
+			case arg_double:
+DBG("double\n");
+				result = myatod(opts->argptr, optarg, arg_double);
+			break;
+			case arg_float:
+DBG("double\n");
+				result = myatod(opts->argptr, optarg, arg_float);
+			break;
+			case arg_string:
+DBG("string\n");
+				result = (*((char **)opts->argptr) = strdup(optarg));
+			break;
+			case arg_function:
+DBG("function\n");
+				result = ((argfn)opts->argptr)(optarg, optind);
+			break;
+		}
+		if(!result){
+DBG("OOOPS! Error in result\n");
+			showhelp(optind, options);
+		}
+	}
+	*argc -= optind;
+	*argv += optind;
+}
+
+/**
+ * Show help information based on myoption->help values
+ * @param oindex (i)  - if non-negative, show only help by myoption[oindex].help
+ * @param options (i) - array of `myoption`
+ *
+ * @exit:  run `exit(-1)` !!!
+ */
+void showhelp(int oindex, myoption *options){
+	// ATTENTION: string `help` prints through macro PRNT(), bu default it is gettext,
+	// but you can redefine it before `#include "parceargs.h"`
+	int max_opt_len = 0; // max len of options substring - for right indentation
+	const int bufsz = 255;
+	char buf[bufsz+1];
+	myoption *opts = options;
+	assert(opts);
+	assert(opts[0].name); // check whether there is at least one options
+	if(oindex > -1){ // print only one message
+		opts = &options[oindex];
+		printf("  ");
+		if(!opts->flag && isalpha(opts->val)) printf("-%c, ", opts->val);
+		printf("--%s", opts->name);
+		if(opts->has_arg == 1) printf("=arg");
+		else if(opts->has_arg == 2) printf("[=arg]");
+		printf("  %s\n", PRNT(opts->help));
+		exit(-1);
+	}
+	// header, by default is just "progname\n"
+	printf("\n");
+	if(strstr(helpstring, "%s")) // print progname
+		printf(helpstring, __progname);
+	else // only text
+		printf("%s", helpstring);
+	printf("\n");
+	// count max_opt_len
+	do{
+		int L = strlen(opts->name);
+		if(max_opt_len < L) max_opt_len = L;
+	}while((++opts)->name);
+	max_opt_len += 14; // format: '-S , --long[=arg]' - get addition 13 symbols
+	opts = options;
+	// Now print all help
+	do{
+		int p = sprintf(buf, "  "); // a little indent
+		if(!opts->flag && isalpha(opts->val)) // .val is short argument
+			p += snprintf(buf+p, bufsz-p, "-%c, ", opts->val);
+		p += snprintf(buf+p, bufsz-p, "--%s", opts->name);
+		if(opts->has_arg == 1) // required argument
+			p += snprintf(buf+p, bufsz-p, "=arg");
+		else if(opts->has_arg == 2) // optional argument
+			p += snprintf(buf+p, bufsz-p, "[=arg]");
+		assert(p < max_opt_len); // there would be magic if p >= max_opt_len
+		printf("%-*s%s\n", max_opt_len+1, buf, PRNT(opts->help)); // write options & at least 2 spaces after
+	}while((++opts)->name);
+	printf("\n\n");
+	exit(-1);
+}

Trinamic/SHA_client_cmdline/parceargs.h

@@ -0,0 +1,105 @@
+/*
+ * parceargs.h - headers for parcing command line arguments
+ *
+ * Copyright 2013 Edward V. Emelianoff <eddy@sao.ru>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+#pragma once
+#ifndef __PARCEARGS_H__
+#define __PARCEARGS_H__
+
+#include <stdbool.h>// bool
+#include <stdlib.h>
+
+#ifndef TRUE
+	#define TRUE true
+#endif
+
+#ifndef FALSE
+	#define FALSE false
+#endif
+
+// macro for argptr
+#define APTR(x)   ((void*)x)
+
+// if argptr is a function:
+typedef  bool(*argfn)(void *arg, int N);
+
+/*
+ * type of getopt's argument
+ * WARNING!
+ * My function change value of flags by pointer, so if you want to use another type
+ * make a latter conversion, example:
+ * 		char charg;
+ * 		int iarg;
+ * 		myoption opts[] = {
+ * 		{"value", 1, NULL, 'v', arg_int, &iarg, "char val"}, ..., end_option};
+ * 		..(parce args)..
+ * 		charg = (char) iarg;
+ */
+typedef enum {
+	arg_none = 0,	// no arg
+	arg_int,		// integer
+	arg_longlong,	// long long
+	arg_double,		// double
+	arg_float,		// float
+	arg_string,		// char *
+	arg_function	// parce_args will run function `bool (*fn)(char *optarg, int N)`
+} argtype;
+
+/*
+ * Structure for getopt_long & help
+ * BE CAREFUL: .argptr is pointer to data or pointer to function,
+ * 		conversion depends on .type
+ *
+ * ATTENTION: string `help` prints through macro PRNT(), bu default it is gettext,
+ * but you can redefine it before `#include "parceargs.h"`
+ *
+ * if arg is string, then value wil be strdup'ed like that:
+ * 		char *str;
+ * 		myoption opts[] = {{"string", 1, NULL, 's', arg_string, &str, "string val"}, ..., end_option};
+ *		*(opts[1].str) = strdup(optarg);
+ * in other cases argptr should be address of some variable (or pointer to allocated memory)
+ *
+ * NON-NULL argptr should be written inside macro APTR(argptr) or directly: (void*)argptr
+ *
+ * !!!LAST VALUE OF ARRAY SHOULD BE `end_option` or ZEROS !!!
+ *
+ */
+typedef struct{
+	// these are from struct option:
+	const char *name;		// long option's name
+	int         has_arg;	// 0 - no args, 1 - nesessary arg, 2 - optionally arg
+	int        *flag;		// NULL to return val, pointer to int - to set its value of val (function returns 0)
+	int         val;		// short opt name (if flag == NULL) or flag's value
+	// and these are mine:
+	argtype     type;		// type of argument
+	void       *argptr;		// pointer to variable to assign optarg value or function `bool (*fn)(char *optarg, int N)`
+	char       *help;		// help string which would be shown in function `showhelp` or NULL
+} myoption;
+
+// last string of array (all zeros)
+#define end_option {0,0,0,0,0,0,0}
+
+
+extern const char *__progname;
+
+void showhelp(int oindex, myoption *options);
+void parceargs(int *argc, char ***argv, myoption *options);
+void change_helpstring(char *s);
+
+#endif // __PARCEARGS_H__