diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..a2b0c92 --- /dev/null +++ b/Makefile @@ -0,0 +1,43 @@ +# run `make DEF=...` to add extra defines +PROGRAM := boltwood +LDFLAGS := -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--discard-all +SRCS := $(wildcard *.c) +DEFINES := $(DEF) -D_GNU_SOURCE -D_XOPEN_SOURCE=1111 +DEFINES += -DEBUG +OBJDIR := mk +CFLAGS += -O2 -Wall -Werror -Wextra -Wno-trampolines -std=gnu99 +OBJS := $(addprefix $(OBJDIR)/, $(SRCS:%.c=%.o)) +DEPS := $(OBJS:.o=.d) +CC = gcc +#CXX = g++ + + +all : $(OBJDIR) $(PROGRAM) + +$(PROGRAM) : $(OBJS) + @echo -e "\t\tLD $(PROGRAM)" + $(CC) $(LDFLAGS) $(OBJS) -o $(PROGRAM) + +$(OBJDIR): + mkdir $(OBJDIR) + +ifneq ($(MAKECMDGOALS),clean) +-include $(DEPS) +endif + +$(OBJDIR)/%.o: %.c + @echo -e "\t\tCC $<" + $(CC) -MD -c $(LDFLAGS) $(CFLAGS) $(DEFINES) -o $@ $< + +clean: + @echo -e "\t\tCLEAN" + @rm -f $(OBJS) $(DEPS) + @rmdir $(OBJDIR) 2>/dev/null || true + +xclean: clean + @rm -f $(PROGRAM) + +gentags: + CFLAGS="$(CFLAGS) $(DEFINES)" geany -g $(PROGRAM).c.tags *[hc] 2>/dev/null + +.PHONY: gentags clean xclean diff --git a/Protocol.md b/Protocol.md new file mode 100644 index 0000000..3e22c85 --- /dev/null +++ b/Protocol.md @@ -0,0 +1,215 @@ +# Boltwood CS || protocol +================ + +## Sensor as receiver + +* 0x01 - REQUEST_POLL - say that there's someone waiting for data +* 0x02 - FRAME_START - data frame start (ending with '\n') + +Without getting REQUEST_POLL, sensor will send data for 5 times and sleep. + +All given symbols go after FRAME_START: + +* 'a' - ACK (should be sent by computer after each good data portion) +* 'm' - next text is command sequence following by CRC16 ('m' not used in CRC) +* 'n' - NACK (should be sent by computer after each bad data portion) + +Commands (ending with CRC16\n) + +* 'b' - close Roof +* 'c' - get calibration +* 'l' - get wetness calibration +* 't' following by 5 integers - set thresholds +* 't' without data - set default thresholds + +After sending command wait a little for getting ACK ('A'). If none (or NACK), try again. +All received data will be sent back in 'Q' frame type. + +## Sensor as sender + +* 0x02 - FRAME_START +* '!' - PURGE_START +* '|' - MEMORY_DUMP_START +* '^' - BOOT_LOADER_START + +All given commands go after FRAME_START: + +* 'A' - ACK +* 'M' - report data frame +* 'N' - NACK +* 'P' - poll request (before FRAME_START there's one 0x00 byte) + +### Report data frame types + +* 'C' - termopile calibration +* 'D' - **sensor report** +* 'I' - reset +* 'K' - wetness calibration +* 'Q' - report a command received from the PC +* 'R' - roof close +* 'T' - thresholds +* 'W' - wetness data +>> debugging??? +* 'X' - "X rhr %d %f", rhr, rainheatt (control of the rain heater) +* 'Y' - "Y %f %d %d", rainheatt, suppressrh, suppressrrh (direct setting of the rain heater target temperature) +* 'Z' - "Z %d %d %d", rainheatt, suppressrh, suppressrrh (direct setting of the rain heater PWM hardware value) + +## Data parameters and fields + +### Set thresholds ("t 1 2 3 4 5") +(integer values) + +1. cloudy threshold *10 +1. very cloudy threshold *10 +1. windy threshold *10 +1. rain threshold (equal) +1. wet threshold (equal) + +### Termopile calibration ('C') + "C %d %lf %lf %lf" +1. eThermopileCal (1) +1. eBestK (-6.571e-7) +1. eBestD (0.371) +1. eBestOffs (-2.00) +1. ? (10.1) + +### Sensor report ('D') + D %u %u %u %u %u %u %lf %lf %lf %c %c %d %lf %lf %d %lf %d %lf %lf %d %d %d %d %d %u %u %u %u %u %u %lf %d %d %u %u" +1. humidstatTempCode - humidity and ambient temperature sensor code (0) +> 0 = OK; + 1 - write failure for humidity; + 2 - measurement never finished for humidity; + 3 - write failure for ambient; + 4 - measurement never finished for ambient; + 5 - data line was not high for humidity; + 6 - data line was not high for ambient. +1. cloudCond - cloud conditions (3) +> (dT = skyMinusAmbientTemperature) + 0 - unknown; + 1 - clear (dT > eCloudyThresh); + 2 - cloudy (dT <= eCloudyThresh); 3 - very cloudy (dT <= eVeryCloudyThresh) +1. windCond - wind conditions (1) +> 0 - unknown (e.g., sensor wet); + 1 - ok (windSpeed < eWindyThresh); + 2 - windy (windSpeed >= eWindyThresh); + 3 - very windy (windSpeed >= eVeryWindyThresh). +1. rainCond - rain sensor conditions (1) +> 0 - unknown; + 1 - not raining; + 2 - recently raining; + 3 - raining. +1. skyCond - sky sensor conditions (3) +> 0 - unknown; + 1 - clear; + 2 - cloudy; + 3 - very cloudy; + 4 - wet. +1. roofCloseRequested =0 normally, =1 if roof close was requested on this cycle (1) +1. skyMinusAmbientTemperature - Tsky-Tamb (-3.1) +> Tsky: 999.9 saturated hot; + -999.9 saturated cold; + -998.0 if sensor is wet. +1. ambientTemperature - ambient temperature (29.3) +> if -40 and humidity is 0 there is a problem with communication to those sensors + (likely water where it shouldn't be). +1. windSpeed - wind speed (0.0) +> -1 - still heating; -2 - wet; -4 - not heating; -5 - shortened circuit; -6 - no probe +1. wetSensor - wet sensor value (N) +> 'N' when dry, 'W' when wet now, 'w' when wet in last minute +1. rainSensor - rain sensor value (N) +> 'N' when no rain, 'R' when rain drops hit on this cycle, 'r' for drops in last + minute +1. relativeHumidityPercentage - relative humidity in % (22) +1. dewPointTemperature - dew point temperature (5.2) +1. caseTemperature - thermopile case temperature(41.2) +> 999.9 saturated hot, -99.9 saturated cold +1. rainHeaterPercentage - PWM percentage for rain heater (0) +1. blackBodyTemperature - calibration black body temperature (factory only) (-99.9) +> 999.9 - saturated hot, + -99.9 - saturated cold. +1. rainHeaterState - state of rain sensor heater (0) +> 0 if too hot; + 1 if at or nearly at requested temp; + 2..5 if too cold; + 6 if cannot control due to a saturated case temperature (causes shutdown); + 7 is used by firmware (tmain) to indicate that normal control is being used instead of direct + use of this. +1. powerVoltage - voltage actually on the +24V line at the sensor head (24.4) +1. anemometerTemeratureDiff - anemometer tip temperature difference from ambient, limited by reducing + anemometer heater power when 25^o C is reached (24.6) +1. wetnessDrop - maximum drop in wetness oscillator counts this cycle due to rain drops(3) +1. wetnessAvg - wetness oscillator count difference from base dry value (162) +1. wetnessDry - wetness oscillator count difference for current dry from base dry value (213) +1. rainHeaterPWM - rain heater PWM value (000) +1. anemometerHeaterPWM - anemometer heater PWM value (039) +1. thermopileADC - thermopile raw A/D output (0106) +1. thermistorADC - thermopile thermistor raw A/D output (0352) +1. powerADC - power supply voltage monitor raw A/D output (0959) +1. blockADC - calibration block thermistor raw A/D output (1023) +1. anemometerThermistorADC - anemometer tip thermistor raw A/D output (0138) +1. davisVaneADC - Davis vane raw A/D output (only for factory calibration) (0141) +1. dkMPH - external anemometer used (only for factory calibration) (0.0) +1. extAnemometerDirection - external anemometer wind direction (only for factory calibration) (049) +1. rawWetnessOsc - raw counts from the wetness oscillator (12990) +1. dayCond - day conditions value (3) +> 3 full daylight; + 2 twilight; + 1 night; + 0 unknown. +1. daylightADC - daylight photodiode raw A/D output (0502) +> 0 means no light, 1023 max light. + +### Reset ('I') + "I %u %u 0x%x %u 0x%x %u" +1. serialNumber - sensor's serial number +1. version - firmvare version +1. mcucsrv - ??? +1. crashCode - ? +1. lastCyc - ? +1. eSendErrs - (error counter?) + +### Wetness calibration ('K') + "K %d %lf %u %lf %lf %u %d %d" + +1. eWetCal (1) +1. eWetOscFactor (1.001) +1. eRawWetAvg (13228) +1. eCaseT - wetness sensor case temperature (max?) (30.9) +1. eshtAmbientT - ambient (termopile in bottom part of sensor) temperature (to turn on heater?) (24.4) +1. enomOsc (13209) +1. oscDry (213) +1. minWetAvg (161) + + +### Thresholds ('T') + "T %u %u %u %lf %lf %lf %lf %d %d %d %d %d %d %d %d %d %d" +1. serialNumber - sensor's serial number (00794) +1. version - firmvare version (00062) +1. eSendErrs - (error counter?) (02603) +1. eCloudyThresh - cloudy threshold (-25.0) +1. eVeryCloudyThresh - very cloudy threshold (-10.0) +1. eWindyThresh - windy threshold (15.0) +1. eVeryWindyThresh - very windy threshold (WTF?) (30.0) +1. eRainThresh - rain threshold (12) +1. eWetThresh - wet threshold (100) +1. eDaylightCode - daylight code (1) +1. eDayThresh - day threshold (132) +1. eVeryDayThresh - very much light threshold (220) +1. ? Ty (5) +1. ?SNBot (0) +1. ?SNTop (65535) +1. ?EV (0) +1. ?WCC (1) + +### Wetness data ('W') + "W %lf %lf %u %u %u %u %u" + 41.2 29.3 13157 13266 13134 12990 162 + +1. caseVal - current case temperature ? (41.2) +1. ambT - current ambient temperature ? (29.3) +1. wAvgW - ? (13157) +1. wAvgC - ? (13266) +1. nomos - ? (13134) +1. rawWT - ? (12990) +1. wetAvg - ? (162) + diff --git a/Readme.md b/Readme.md new file mode 100644 index 0000000..e5dad7f --- /dev/null +++ b/Readme.md @@ -0,0 +1,5 @@ +Monitoring daemon for BoltWood Cloud Sensor II +================== + +Alfa stage: only passive monitoring +read Protocol.md for protocol details. \ No newline at end of file diff --git a/cmdlnopts.c b/cmdlnopts.c new file mode 100644 index 0000000..9c22f92 --- /dev/null +++ b/cmdlnopts.c @@ -0,0 +1,81 @@ +/* geany_encoding=koi8-r + * cmdlnopts.c - the only function that parse cmdln args and returns glob parameters + * + * Copyright 2013 Edward V. Emelianoff + * + * 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 +#include +#include +#include +#include +#include "cmdlnopts.h" +#include "usefull_macros.h" + +/* + * here are global parameters initialisation + */ +int help; +glob_pars G; + +#define DEFAULT_COMDEV "/dev/ttyUSB0" +// DEFAULTS +// default global parameters +glob_pars const Gdefault = { + .device = DEFAULT_COMDEV, + .port = "55555", + .rest_pars = NULL, + .rest_pars_num = 0, +}; + +/* + * Define command line options by filling structure: + * name has_arg flag val type argptr help +*/ +myoption cmdlnopts[] = { +// common options + {"help", NO_ARGS, NULL, 'h', arg_int, APTR(&help), _("show this help")}, + {"device", NEED_ARG, NULL, 'i', arg_string, APTR(&G.device), _("serial device name (default: " DEFAULT_COMDEV ")")}, + {"port", NEED_ARG, NULL, 'p', arg_string, APTR(&G.port), _("port to connect (default: 4444)")}, + end_option +}; + +/** + * Parse 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 *parse_args(int argc, char **argv){ + int i; + void *ptr; + ptr = memcpy(&G, &Gdefault, sizeof(G)); assert(ptr); + // format of help: "Usage: progname [args]\n" + change_helpstring("Usage: %s [args]\n\n\tWhere args are:\n"); + // parse arguments + parseargs(&argc, &argv, cmdlnopts); + if(help) showhelp(-1, cmdlnopts); + if(argc > 0){ + G.rest_pars_num = argc; + G.rest_pars = calloc(argc, sizeof(char*)); + for (i = 0; i < argc; i++) + G.rest_pars[i] = strdup(argv[i]); + } + return &G; +} + diff --git a/cmdlnopts.h b/cmdlnopts.h new file mode 100644 index 0000000..acbac34 --- /dev/null +++ b/cmdlnopts.h @@ -0,0 +1,41 @@ +/* geany_encoding=koi8-r + * cmdlnopts.h - comand line options for parceargs + * + * Copyright 2013 Edward V. Emelianoff + * + * 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 "parseargs.h" +#include "term.h" + +/* + * here are some typedef's for global data + */ +typedef struct{ + char *device; // serial device name + char *port; // port to connect + int rest_pars_num; // number of rest parameters + char** rest_pars; // the rest parameters: array of char* +} glob_pars; + + +glob_pars *parse_args(int argc, char **argv); +#endif // __CMDLNOPTS_H__ diff --git a/main.c b/main.c new file mode 100644 index 0000000..a7d4fb4 --- /dev/null +++ b/main.c @@ -0,0 +1,44 @@ +/* geany_encoding=koi8-r + * main.c + * + * Copyright 2017 Edward V. Emelianov + * + * 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 "usefull_macros.h" +#include +#include "cmdlnopts.h" + +void signals(int signo){ + restore_console(); + restore_tty(); + exit(signo); +} + +int main(int argc, char **argv){ + initial_setup(); + signal(SIGTERM, signals); // kill (-15) - quit + signal(SIGHUP, SIG_IGN); // hup - ignore + signal(SIGINT, signals); // ctrl+C - quit + signal(SIGQUIT, signals); // ctrl+\ - quit + signal(SIGTSTP, SIG_IGN); // ignore ctrl+Z + glob_pars *G = parse_args(argc, argv); + + try_connect(G->device); + //daemonize(G->hostname, G->port); + run_terminal(); + return 0; +} diff --git a/parseargs.c b/parseargs.c new file mode 100644 index 0000000..b235752 --- /dev/null +++ b/parseargs.c @@ -0,0 +1,497 @@ +/* geany_encoding=koi8-r + * parseargs.c - parsing command line arguments & print help + * + * Copyright 2013 Edward V. Emelianoff + * + * 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 // printf +#include // getopt_long +#include // calloc, exit, strtoll +#include // assert +#include // strdup, strchr, strlen +#include // strcasecmp +#include // INT_MAX & so on +#include // gettext +#include // isalpha +#include "parseargs.h" +#include "usefull_macros.h" + +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 + }; + if(pcount > 1 || pcount != scount){ // amount of pcount and/or scount wrong + /// "Неправильный формат строки помощи" + ERRX(_("Wrong helpstring!")); + } + helpstring = s; +} + +/** + * 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 + */ +static 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){ + /// "Целое вне допустимого диапазона" + WARNX(_("Integer out of range")); + 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?) +static 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 + */ +static 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; +} + +/** + * reallocate new value in array of multiple repeating arguments + * @arg paptr - address of pointer to array (**void) + * @arg type - its type (for realloc) + * @return pointer to new (next) value + */ +void *get_aptr(void *paptr, argtype type){ + int i = 1; + void **aptr = *((void***)paptr); + if(aptr){ // there's something in array + void **p = aptr; + while(*p++) ++i; + } + size_t sz = 0; + switch(type){ + default: + case arg_none: + /// "Не могу использовать несколько параметров без аргументов!" + ERRX("Can't use multiple args with arg_none!"); + break; + case arg_int: + sz = sizeof(int); + break; + case arg_longlong: + sz = sizeof(long long); + break; + case arg_double: + sz = sizeof(double); + break; + case arg_float: + sz = sizeof(float); + break; + case arg_string: + sz = 0; + break; + /* case arg_function: + sz = sizeof(argfn *); + break;*/ + } + aptr = realloc(aptr, (i + 1) * sizeof(void*)); + *((void***)paptr) = aptr; + aptr[i] = NULL; + if(sz){ + aptr[i - 1] = malloc(sz); + }else + aptr[i - 1] = &aptr[i - 1]; + return aptr[i - 1]; +} + + +/** + * Parse 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 parseargs(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; + // in debug mode check the parameters are not repeated +#ifdef EBUG + char **longlist = MALLOC(char*, optsize); + char *shortlist = MALLOC(char, optsize); +#endif + // fill short/long parameters and make a simple checking + for(i = 0; i < optsize; i++, loptr++, opts++){ + // check + assert(opts->name); // check name +#ifdef EBUG + longlist[i] = strdup(opts->name); +#endif + 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 < MULT_PAR) ? opts->has_arg : 1; + loptr->flag = opts->flag; + loptr->val = opts->val; + // fill short options if they are: + if(!opts->flag && opts->val){ +#ifdef EBUG + shortlist[i] = (char) opts->val; +#endif + *soptr++ = opts->val; + if(loptr->has_arg) // add ':' if option has required argument + *soptr++ = ':'; + if(loptr->has_arg == 2) // add '::' if option has optional argument + *soptr++ = ':'; + } + } + // sort all lists & check for repeating +#ifdef EBUG + int cmpstringp(const void *p1, const void *p2){ + return strcmp(* (char * const *) p1, * (char * const *) p2); + } + int cmpcharp(const void *p1, const void *p2){ + return (int)(*(char * const)p1 - *(char *const)p2); + } + qsort(longlist, optsize, sizeof(char *), cmpstringp); + qsort(shortlist,optsize, sizeof(char), cmpcharp); + char *prevl = longlist[0], prevshrt = shortlist[0]; + for(i = 1; i < optsize; ++i){ + if(longlist[i]){ + if(prevl){ + if(strcmp(prevl, longlist[i]) == 0) ERRX("double long arguments: --%s", prevl); + } + prevl = longlist[i]; + } + if(shortlist[i]){ + if(prevshrt){ + if(prevshrt == shortlist[i]) ERRX("double short arguments: -%c", prevshrt); + } + prevshrt = shortlist[i]; + } + } +#endif + // 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 == NEED_ARG || options[optind].has_arg == MULT_PAR) + showhelp(optind, options); // need argument + } + else{ + if(opt == 0 || oindex > 0) optind = oindex; + else optind = get_optind(opt, options); + } + opts = &options[optind]; + // if(opt == 0 && opts->has_arg == NO_ARGS) continue; // only long option changing integer flag + // now check option + if(opts->has_arg == NEED_ARG || opts->has_arg == MULT_PAR) + if(!optarg) showhelp(optind, options); // need argument + void *aptr; + if(opts->has_arg == MULT_PAR){ + aptr = get_aptr(opts->argptr, opts->type); + }else + aptr = opts->argptr; + 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: + if(opts->argptr) *((int*)aptr) += 1; // increment value + break; + case arg_int: + result = myatoll(aptr, optarg, arg_int); + break; + case arg_longlong: + result = myatoll(aptr, optarg, arg_longlong); + break; + case arg_double: + result = myatod(aptr, optarg, arg_double); + break; + case arg_float: + result = myatod(aptr, optarg, arg_float); + break; + case arg_string: + result = (*((void**)aptr) = (void*)strdup(optarg)); + break; + case arg_function: + result = ((argfn)aptr)(optarg); + break; + } + if(!result){ + showhelp(optind, options); + } + } + *argc -= optind; + *argv += optind; +} + +/** + * compare function for qsort + * first - sort by short options; second - sort arguments without sort opts (by long options) + */ +static int argsort(const void *a1, const void *a2){ + const myoption *o1 = (myoption*)a1, *o2 = (myoption*)a2; + const char *l1 = o1->name, *l2 = o2->name; + int s1 = o1->val, s2 = o2->val; + int *f1 = o1->flag, *f2 = o2->flag; + // check if both options has short arg + if(f1 == NULL && f2 == NULL && s1 && s2){ // both have short arg + return (s1 - s2); + }else if((f1 != NULL || !s1) && (f2 != NULL || !s2)){ // both don't have short arg - sort by long + return strcmp(l1, l2); + }else{ // only one have short arg -- return it + if(f2 || !s2) return -1; // a1 have short - it is 'lesser' + else return 1; + } +} + +/** + * 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){ + 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", _(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; + // count amount of options + int N; for(N = 0; opts->name; ++N, ++opts); + if(N == 0) exit(-2); + // Now print all help (sorted) + opts = options; + qsort(opts, N, sizeof(myoption), argsort); + do{ + int p = sprintf(buf, " "); // a little indent + if(!opts->flag && 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, _(opts->help)); // write options & at least 2 spaces after + ++opts; + }while(--N); + printf("\n\n"); + exit(-1); +} + +/** + * get suboptions from parameter string + * @param str - parameter string + * @param opt - pointer to suboptions structure + * @return TRUE if all OK + */ +bool get_suboption(char *str, mysuboption *opt){ + int findsubopt(char *par, mysuboption *so){ + int idx = 0; + if(!par) return -1; + while(so[idx].name){ + if(strcasecmp(par, so[idx].name) == 0) return idx; + ++idx; + } + return -1; // badarg + } + bool opt_setarg(mysuboption *so, int idx, char *val){ + mysuboption *soptr = &so[idx]; + bool result = FALSE; + void *aptr = soptr->argptr; + switch(soptr->type){ + default: + case arg_none: + if(soptr->argptr) *((int*)aptr) += 1; // increment value + result = TRUE; + break; + case arg_int: + result = myatoll(aptr, val, arg_int); + break; + case arg_longlong: + result = myatoll(aptr, val, arg_longlong); + break; + case arg_double: + result = myatod(aptr, val, arg_double); + break; + case arg_float: + result = myatod(aptr, val, arg_float); + break; + case arg_string: + result = (*((void**)aptr) = (void*)strdup(val)); + break; + case arg_function: + result = ((argfn)aptr)(val); + break; + } + return result; + } + char *tok; + bool ret = FALSE; + char *tmpbuf; + tok = strtok_r(str, ":,", &tmpbuf); + do{ + char *val = strchr(tok, '='); + int noarg = 0; + if(val == NULL){ // no args + val = "1"; + noarg = 1; + }else{ + *val++ = '\0'; + if(!*val || *val == ':' || *val == ','){ // no argument - delimeter after = + val = "1"; noarg = 1; + } + } + int idx = findsubopt(tok, opt); + if(idx < 0){ + /// "Неправильный параметр: %s" + WARNX(_("Wrong parameter: %s"), tok); + goto returning; + } + if(noarg && opt[idx].has_arg == NEED_ARG){ + /// "%s: необходим аргумент!" + WARNX(_("%s: argument needed!"), tok); + goto returning; + } + if(!opt_setarg(opt, idx, val)){ + /// "Неправильный аргумент \"%s\" параметра \"%s\"" + WARNX(_("Wrong argument \"%s\" of parameter \"%s\""), val, tok); + goto returning; + } + }while((tok = strtok_r(NULL, ":,", &tmpbuf))); + ret = TRUE; +returning: + return ret; +} diff --git a/parseargs.h b/parseargs.h new file mode 100644 index 0000000..537fc5b --- /dev/null +++ b/parseargs.h @@ -0,0 +1,124 @@ +/* geany_encoding=koi8-r + * parseargs.h - headers for parsing command line arguments + * + * Copyright 2013 Edward V. Emelianoff + * + * 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 __PARSEARGS_H__ +#define __PARSEARGS_H__ + +#include // bool +#include + +#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); + +/* + * 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}; + * ..(parse 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 // parse_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 "parseargs.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 enum{ + NO_ARGS = 0, // first three are the same as in getopt_long + NEED_ARG = 1, + OPT_ARG = 2, + MULT_PAR +} hasarg; + +typedef struct{ + // these are from struct option: + const char *name; // long option's name + hasarg has_arg; // 0 - no args, 1 - nesessary arg, 2 - optionally arg, 4 - need arg & key can repeat (args are stored in null-terminated array) + 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)` + const char *help; // help string which would be shown in function `showhelp` or NULL +} myoption; + +/* + * Suboptions structure, almost the same like myoption + * used in parse_subopts() + */ +typedef struct{ + const char *name; + hasarg has_arg; + argtype type; + void *argptr; +} mysuboption; + +// last string of array (all zeros) +#define end_option {0,0,0,0,0,0,0} +#define end_suboption {0,0,0,0} + +extern const char *__progname; + +void showhelp(int oindex, myoption *options); +void parseargs(int *argc, char ***argv, myoption *options); +void change_helpstring(char *s); +bool get_suboption(char *str, mysuboption *opt); + +#endif // __PARSEARGS_H__ diff --git a/socket.c b/socket.c new file mode 100644 index 0000000..c988d98 --- /dev/null +++ b/socket.c @@ -0,0 +1,331 @@ +/* + * geany_encoding=koi8-r + * socket.c - socket IO (both client & server) + * + * Copyright 2017 Edward V. Emelianov + * + * 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 "usefull_macros.h" +#include "socket.h" +#include "term.h" +#include // addrinfo +#include // inet_ntop +#include +#include // INT_xxx +#include // pthread_kill +#include // daemon +#include // wait +#include //prctl + +#define BUFLEN (10240) +#define BUFLEN10 (1048576) +// Max amount of connections +#define BACKLOG (30) + +/**************** COMMON FUNCTIONS ****************/ +/** + * wait for answer from socket + * @param sock - socket fd + * @return 0 in case of error or timeout, 1 in case of socket ready + */ +static int waittoread(int sock){ + fd_set fds; + struct timeval timeout; + int rc; + timeout.tv_sec = 1; // wait not more than 1 second + timeout.tv_usec = 0; + FD_ZERO(&fds); + FD_SET(sock, &fds); + do{ + rc = select(sock+1, &fds, NULL, NULL, &timeout); + if(rc < 0){ + if(errno != EINTR){ + WARN("select()"); + return 0; + } + continue; + } + break; + }while(1); + if(FD_ISSET(sock, &fds)) return 1; + return 0; +} + +static uint8_t *findpar(uint8_t *str, char *par){ + size_t L = strlen(par); + char *f = strstr((char*)str, par); + if(!f) return NULL; + f += L; + if(*f != '=') return NULL; + return (uint8_t*)(f + 1); +} +/** + * get integer & double `parameter` value from string `str`, put value to `ret` + * @return 1 if all OK + */ +static long getintpar(uint8_t *str, char *parameter, long *ret){ + long tmp; + char *endptr; + if(!(str = findpar(str, parameter))) return 0; + tmp = strtol((char*)str, &endptr, 0); + if(endptr == (char*)str || *str == 0 ) + return 0; + if(ret) *ret = tmp; + DBG("get par: %s = %ld", parameter, tmp); + return 1; +} +static int getdpar(uint8_t *str, char *parameter, double *ret){ + double tmp; + char *endptr; + if(!(str = findpar(str, parameter))) return 0; + tmp = strtod((char*)str, &endptr); + if(endptr == (char*)str || *str == 0) + return 0; + if(ret) *ret = tmp; + DBG("get par: %s = %g", parameter, tmp); + return 1; +} + +/**************** SERVER FUNCTIONS ****************/ +pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; +/* +int send_ima(int sock, int webquery){ + uint8_t buf[BUFLEN10], *bptr = buf, obuff[BUFLEN]; + ssize_t Len; + size_t rest = BUFLEN10, imS = storedima->W * storedima->H * sizeof(uint16_t); + #define PUT(key, val) do{Len = snprintf((char*)bptr, rest, "%s=%i\n", key, (int)storedima->val); \ + if(Len > 0){rest -= Len; bptr += Len;}}while(0) + PUT("binning", binning); + if(storedima->binning == 0xff){ + PUT("subX", subframe->Xstart); + PUT("subY", subframe->Xstart); + PUT("subS", subframe->size); + } + Len = snprintf((char*)bptr, rest, "%s=%g\n", "exptime", storedima->exptime); + if(Len > 0){rest -= Len; bptr += Len;} + PUT("imtype", imtype); + PUT("imW", W); + PUT("imH", H); + PUT("exposetime", exposetime); + Len = snprintf((char*)bptr, rest, "imdata="); + if(Len){rest -= Len; bptr += Len;} + if(rest < imS){ + red("rest = %zd, need %zd\n", rest, imS); + return 0; // not enough memory - HOW??? + } + if(!memcpy(bptr, storedima->imdata, imS)){ + WARN("memcpy()"); + return 0; + } + rest -= imS; + // OK buffer ready, prepare to send it + if(webquery){ + Len = snprintf((char*)obuff, BUFLEN, + "HTTP/2.0 200 OK\r\n" + "Access-Control-Allow-Origin: *\r\n" + "Access-Control-Allow-Methods: GET, POST\r\n" + "Access-Control-Allow-Credentials: true\r\n" + "Content-type: multipart/form-data\r\nContent-Length: %zd\r\n\r\n", Len); + if(Len < 0){ + WARN("sprintf()"); + return 0; + } + if(Len != write(sock, obuff, Len)){ + WARN("write"); + return 0; + } + DBG("%s", obuff); + } + // send data + size_t send = BUFLEN10 - rest; + red("send %zd bytes\n", send); + if(send != (size_t)write(sock, buf, send)){ + WARN("write()"); + return 0; + } + return 1; +}*/ + +// search a first word after needle without spaces +char* stringscan(char *str, char *needle){ + char *a, *e; + char *end = str + strlen(str); + a = strstr(str, needle); + if(!a) return NULL; + a += strlen(needle); + while (a < end && (*a == ' ' || *a == '\r' || *a == '\t' || *a == '\r')) a++; + if(a >= end) return NULL; + e = strchr(a, ' '); + if(e) *e = 0; + return a; +} + +void *handle_socket(void *asock){ + FNAME(); + int sock = *((int*)asock); + //int webquery = 0; // whether query is web or regular + char buff[BUFLEN]; + ssize_t readed; + while(1){ + if(!waittoread(sock)){ // no data incoming + /* pthread_mutex_lock(&mutex); + red("Send image, imctr = %ld, locctr = %ld\n", imctr, locctr); + if(send_ima(sock, webquery)){ + locctr = imctr; + if(webquery){ + pthread_mutex_unlock(&mutex); + break; // end of transmission + } + } + pthread_mutex_unlock(&mutex);*/ + continue; + } + if(!(readed = read(sock, buff, BUFLEN))) continue; + DBG("Got %zd bytes", readed); + if(readed < 0){ // error or disconnect + DBG("Nothing to read from fd %d (ret: %zd)", sock, readed); + break; + } + // add trailing zero to be on the safe side + buff[readed] = 0; + // now we should check what do user want + char *got, *found = buff; + if((got = stringscan(buff, "GET")) || (got = stringscan(buff, "POST"))){ // web query + //webquery = 1; + char *slash = strchr(got, '/'); + if(slash) found = slash + 1; + // web query have format GET /some.resource + } + // here we can process user data + printf("user send: %s\n", found); + long ii; double dd; + if(getdpar((uint8_t*)found, "exptime", &dd)) printf("exptime: %g\n", dd); + if(getintpar((uint8_t*)found, "somepar", &ii)) printf("somepar: %ld\n", ii); + } + close(sock); + //DBG("closed"); + pthread_exit(NULL); + return NULL; +} + +void *server(void *asock){ + int sock = *((int*)asock); + if(listen(sock, BACKLOG) == -1){ + WARN("listen"); + return NULL; + } + while(1){ + socklen_t size = sizeof(struct sockaddr_in); + struct sockaddr_in their_addr; + int newsock; + if(!waittoread(sock)) continue; + red("Got connection\n"); + newsock = accept(sock, (struct sockaddr*)&their_addr, &size); + if(newsock <= 0){ + WARN("accept()"); + continue; + } + pthread_t handler_thread; + if(pthread_create(&handler_thread, NULL, handle_socket, (void*) &newsock)) + WARN("pthread_create()"); + else{ + DBG("Thread created, detouch"); + pthread_detach(handler_thread); // don't care about thread state + } + } +} + +static void daemon_(int sock){ + FNAME(); + if(sock < 0) return; + pthread_t sock_thread; + if(pthread_create(&sock_thread, NULL, server, (void*) &sock)) + ERR("pthread_create()"); + do{ + if(pthread_kill(sock_thread, 0) == ESRCH){ // died + WARNX("Sockets thread died"); + pthread_join(sock_thread, NULL); + if(pthread_create(&sock_thread, NULL, server, (void*) &sock)) + ERR("pthread_create()"); + } + }while(1); +} + +/** + * Run daemon service + */ +void daemonize(char *port){ + FNAME(); +#ifndef EBUG + green("Daemonize\n"); + if(daemon(1, 0)){ + ERR("daemon()"); + } + while(1){ // guard for dead processes + pid_t childpid = fork(); + if(childpid){ + DBG("Created child with PID %d\n", childpid); + wait(NULL); + WARNX("Child %d died\n", childpid); + sleep(1); + }else{ + prctl(PR_SET_PDEATHSIG, SIGTERM); // send SIGTERM to child when parent dies + break; // go out to normal functional + } + } +#endif + int sock = -1; + struct addrinfo hints, *res, *p; + memset(&hints, 0, sizeof(hints)); + hints.ai_family = AF_INET; + hints.ai_socktype = SOCK_STREAM; + hints.ai_flags = AI_PASSIVE; + if(getaddrinfo(NULL, port, &hints, &res) != 0){ + ERR("getaddrinfo"); + } + struct sockaddr_in *ia = (struct sockaddr_in*)res->ai_addr; + char str[INET_ADDRSTRLEN]; + inet_ntop(AF_INET, &(ia->sin_addr), str, INET_ADDRSTRLEN); + DBG("canonname: %s, port: %u, addr: %s\n", res->ai_canonname, ntohs(ia->sin_port), str); + // loop through all the results and bind to the first we can + for(p = res; p != NULL; p = p->ai_next){ + if((sock = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1){ + WARN("socket"); + continue; + } + int reuseaddr = 1; + if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof(int)) == -1){ + ERR("setsockopt"); + } + if(bind(sock, p->ai_addr, p->ai_addrlen) == -1){ + close(sock); + WARN("bind"); + continue; + } + break; // if we get here, we have a successfull connection + } + if(p == NULL){ + // looped off the end of the list with no successful bind + ERRX("failed to bind socket"); + } + freeaddrinfo(res); + daemon_(sock); + close(sock); + signals(0); +} + diff --git a/socket.h b/socket.h new file mode 100644 index 0000000..ec5e0a7 --- /dev/null +++ b/socket.h @@ -0,0 +1,29 @@ +/* + * geany_encoding=koi8-r + * socket.h + * + * Copyright 2017 Edward V. Emelianov + * + * 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 __SOCKET_H__ +#define __SOCKET_H__ + +void daemonize(char *port); + +#endif // __SOCKET_H__ diff --git a/term.c b/term.c new file mode 100644 index 0000000..875db9b --- /dev/null +++ b/term.c @@ -0,0 +1,236 @@ +/* geany_encoding=koi8-r + * client.c - simple terminal client + * + * Copyright 2013 Edward V. Emelianoff + * + * 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 "usefull_macros.h" +#include "term.h" +#include // strncasecmp +#include // time(NULL) + +#define BUFLEN 1024 + +static uint16_t calcCRC16(const uint8_t *buf, int nBytes){ + /* Table generated using code written by Michael Barr + * (http://www.netrino.com/Connecting/2000-01/crc.zip). + */ + const uint16_t crc16Table[] = { + 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7, + 0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef, + 0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6, + 0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de, + 0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485, + 0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d, + 0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4, + 0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc, + 0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823, + 0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b, + 0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12, + 0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a, + 0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41, + 0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49, + 0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70, + 0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78, + 0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f, + 0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067, + 0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e, + 0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256, + 0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d, + 0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, + 0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c, + 0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634, + 0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab, + 0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3, + 0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a, + 0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92, + 0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9, + 0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1, + 0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8, + 0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0, + }; + + uint16_t crc = 0; + int i; + for (i = 0 ; i < nBytes; ++i) + crc = (uint16_t) ((crc << 8) ^ crc16Table[((crc >> 8) ^ buf[i]) & 0xff]); + return crc; +} + +/** + * Send command by serial port, return 0 if all OK + *static uint8_t last_chksum = 0; +int send_data(uint8_t *buf, int len){ + if(len < 1) return 1; + uint8_t chksum = 0, *ptr = buf; + int l; + for(l = 0; l < len; ++l) + chksum ^= ~(*ptr++) & 0x7f; + DBG("send: %s (chksum: 0x%X)", buf, chksum); + if(write_tty(buf, len)) return 1; + DBG("cmd sent"); + if(write_tty(&chksum, 1)) return 1; + DBG("checksum sent"); + last_chksum = chksum; + return 0; +}*/ + +// send single symbol without CRC +int send_symbol(uint8_t cmd){ + uint8_t s[5] = {FRAME_START, cmd, '\n', REQUEST_POLL, 0}; + if(write_tty(s, 4)) return 1; + //DBG("sent: %02x%s%02x", s[0], &s[1], s[3]); + return 0; +} + +/** + * read string from terminal (ending with '\n') with timeout + * @param str (o) - buffer for string + * @param L - its length + * @return number of characters read + */ +static size_t read_string(uint8_t *str, int L){ + size_t r = 0, l; + uint8_t *ptr = str; + double d0 = dtime(); + do{ + if((l = read_tty(ptr, L))){ + r += l; L -= l; ptr += l; + if(ptr[-1] == '\n') break; + d0 = dtime(); + } + }while(dtime() - d0 < WAIT_TMOUT); + return r; +} + +/** + * Send command with CRC and ACK waiting + * @return 0 if all OK + */ +int send_cmd(uint8_t cmd){ + uint8_t buf[BUFLEN]; + uint8_t s[10] = {FRAME_START, 'm', cmd,0}; + uint16_t crc = calcCRC16(&cmd, 1); + snprintf((char*)&s[3], 6, "%04X\n", crc); // snprintf adds trailing zero + s[8] = REQUEST_POLL; + if(write_tty(s, 9)) return 1; + int i, acked = 0; + for(i = 0; i < 5; ++i){ + size_t L = read_string(buf, BUFLEN); + if(L > 2){ + if( (buf[0] == FRAME_START && buf[1] == ANS_COMMAND_ACKED) || + (buf[1] == FRAME_START && buf[2] == ANS_COMMAND_ACKED)){ + acked = 1; + break; + } + } + } + if(acked){ + //DBG("sent: %02x%s%02x", s[0], &s[1], s[8]); + return 0; + } + return 1; +} + +/** + * Try to connect to `device` at given speed (or try all speeds, if speed == 0) + * @return connection speed if success or 0 + */ +int try_connect(char *device){ + if(!device) return 0; + uint8_t tmpbuf[4096]; + green(_("Connecting to %s... "), device); + fflush(stdout); + tty_init(device); + read_tty(tmpbuf, 4096); // clear rbuf + green("Ok!"); + printf("\n\n"); + return 0; +} + +// check CRC and return 0 if all OK +int chk_crc(uint8_t *buf){ + if(!buf) return 1; + // DBG("CRC for %s", buf); + uint8_t *strend = (uint8_t*) strchr((char*)buf, '\n'); + if(!strend) return 2; + int L = (int) (strend - buf) - 4; + if(L < 1) return 4; // string too short + uint16_t calc = calcCRC16(buf, L); + char *eptr; + strend -= 4; + unsigned long got = strtoul((char*)strend, &eptr, 16); + // DBG("calc: 0x%x, got: 0x%lx", calc, got); + if(eptr == (char*)strend || (*eptr && *eptr != '\n')) return 5; // bad input CRC + if((uint16_t)got != calc) return 6; // not equal + return 0; +} + +/** + * run terminal emulation: send user's commands with checksum and show answers + */ +void run_terminal(){ + green(_("Work in terminal mode without echo\n")); + int rb; + uint8_t usercmd = 0; + uint8_t buf[BUFLEN], cmd; + size_t L; + setup_con(); + cmd = REQUEST_POLL; + if(write_tty(&cmd, 1)) // start polling + WARNX(_("can't request poll")); + while(1){ + if((L = read_string(buf, BUFLEN))){ + if(L > 5 && buf[1] == ANS_DATA_FRAME){ + if(chk_crc(&buf[2])){ + WARNX(_("Bad CRC in input data")); + send_symbol(CMD_NACK); + continue; + } + buf[L-5] = 0; + send_symbol(CMD_ACK); + }else if(L > 1){ + if(buf[1] == ANS_POLLING_FRAME || buf[2] == ANS_POLLING_FRAME){ // polling - send command or ack + if(usercmd){ + if(!send_cmd(usercmd)) + usercmd = 0; + }else + send_symbol(CMD_ACK); + } + continue; + } else continue; + // print out data frames + uint8_t *ptr = &buf[1], c; + while(L-- && (c = *ptr++)){ + if(c > 31) printf("%c", (char)c); + else printf("[0x%02x]", c); + } + printf("\n"); + } + if((rb = read_console())){ + if(rb > 31){ + if(send_cmd((uint8_t)rb)) + usercmd = (uint8_t)rb;//send_cmd((uint8_t)rb); + }else if(rb == '\n'){ + cmd = REQUEST_POLL; + if(write_tty(&cmd, 1)) + WARNX(_("can't request poll")); + } + } + } +} + diff --git a/term.h b/term.h new file mode 100644 index 0000000..6e90fdb --- /dev/null +++ b/term.h @@ -0,0 +1,66 @@ +/* geany_encoding=koi8-r + * term.h - functions to work with serial terminal + * + * Copyright 2017 Edward V. Emelianov + * + * 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 __TERM_H__ +#define __TERM_H__ + +// communication errors +typedef enum{ + TRANS_SUCCEED = 0, // no errors + TRANS_ERROR, // some error occured + TRANS_BADCHSUM, // wrong checksum + TRANS_TIMEOUT, // no data for 0.1s + TRANS_TRYAGAIN, // checksum return 0x7f - maybe try again? + TRANS_BUSY // image exposure in progress +} trans_status; + +typedef enum{ + PURGE_START = '!', + MEMORY_DUMP_START = '|', + BOOT_LOADER_START = '^', + REQUEST_POLL = 0x01, /* SOH */ + FRAME_START = 0x02, /* STX */ + FRAME_END = '\n', +} term_symbols; + +#define FRAME_MAX_LENGTH (300) +#define MAX_MEMORY_DUMP_SIZE (0x800 * 4) + + +// terminal timeout (seconds) +#define WAIT_TMOUT (0.2) + +/******************************** Commands definition ********************************/ +#define CMD_ACK 'a' +#define CMD_NACK 'n' + + + + +/******************************** Answers definition ********************************/ +#define ANS_COMMAND_ACKED 'A' +#define ANS_COMMAND_NACKED 'N' +#define ANS_DATA_FRAME 'M' +#define ANS_POLLING_FRAME 'P' + +void run_terminal(); +int try_connect(char *device); +#endif // __TERM_H__ diff --git a/usefull_macros.c b/usefull_macros.c new file mode 100644 index 0000000..a56c8b8 --- /dev/null +++ b/usefull_macros.c @@ -0,0 +1,381 @@ +/* + * usefull_macros.h - a set of usefull functions: memory, color etc + * + * Copyright 2013 Edward V. Emelianoff + * + * 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 "usefull_macros.h" + +/** + * function for different purposes that need to know time intervals + * @return double value: time in seconds + */ +double dtime(){ + double t; + struct timeval tv; + gettimeofday(&tv, NULL); + t = tv.tv_sec + ((double)tv.tv_usec)/1e6; + return t; +} + +/******************************************************************************\ + * Coloured terminal +\******************************************************************************/ +int globErr = 0; // errno for WARN/ERR + +// pointers to coloured output printf +int (*red)(const char *fmt, ...); +int (*green)(const char *fmt, ...); +int (*_WARN)(const char *fmt, ...); + +/* + * format red / green messages + * name: r_pr_, g_pr_ + * @param fmt ... - printf-like format + * @return number of printed symbols + */ +int r_pr_(const char *fmt, ...){ + va_list ar; int i; + printf(RED); + va_start(ar, fmt); + i = vprintf(fmt, ar); + va_end(ar); + printf(OLDCOLOR); + return i; +} +int g_pr_(const char *fmt, ...){ + va_list ar; int i; + printf(GREEN); + va_start(ar, fmt); + i = vprintf(fmt, ar); + va_end(ar); + printf(OLDCOLOR); + return i; +} +/* + * print red error/warning messages (if output is a tty) + * @param fmt ... - printf-like format + * @return number of printed symbols + */ +int r_WARN(const char *fmt, ...){ + va_list ar; int i = 1; + fprintf(stderr, RED); + va_start(ar, fmt); + if(globErr){ + errno = globErr; + vwarn(fmt, ar); + errno = 0; + }else + i = vfprintf(stderr, fmt, ar); + va_end(ar); + i++; + fprintf(stderr, OLDCOLOR "\n"); + return i; +} + +static const char stars[] = "****************************************"; +/* + * notty variants of coloured printf + * name: s_WARN, r_pr_notty + * @param fmt ... - printf-like format + * @return number of printed symbols + */ +int s_WARN(const char *fmt, ...){ + va_list ar; int i; + i = fprintf(stderr, "\n%s\n", stars); + va_start(ar, fmt); + if(globErr){ + errno = globErr; + vwarn(fmt, ar); + errno = 0; + }else + i = +vfprintf(stderr, fmt, ar); + va_end(ar); + i += fprintf(stderr, "\n%s\n", stars); + i += fprintf(stderr, "\n"); + return i; +} +int r_pr_notty(const char *fmt, ...){ + va_list ar; int i; + i = printf("\n%s\n", stars); + va_start(ar, fmt); + i += vprintf(fmt, ar); + va_end(ar); + i += printf("\n%s\n", stars); + return i; +} + +/** + * Run this function in the beginning of main() to setup locale & coloured output + */ +void initial_setup(){ + // setup coloured output + if(isatty(STDOUT_FILENO)){ // make color output in tty + red = r_pr_; green = g_pr_; + }else{ // no colors in case of pipe + red = r_pr_notty; green = printf; + } + if(isatty(STDERR_FILENO)) _WARN = r_WARN; + else _WARN = s_WARN; + // Setup locale + setlocale(LC_ALL, ""); + setlocale(LC_NUMERIC, "C"); +#if defined GETTEXT_PACKAGE && defined LOCALEDIR + bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR); + textdomain(GETTEXT_PACKAGE); +#endif +} + +/******************************************************************************\ + * Memory +\******************************************************************************/ +/* + * safe memory allocation for macro ALLOC + * @param N - number of elements to allocate + * @param S - size of single element (typically sizeof) + * @return pointer to allocated memory area + */ +void *my_alloc(size_t N, size_t S){ + void *p = calloc(N, S); + if(!p) ERR("malloc"); + //assert(p); + return p; +} + +/** + * Mmap file to a memory area + * + * @param filename (i) - name of file to mmap + * @return stuct with mmap'ed file or die + */ +mmapbuf *My_mmap(char *filename){ + int fd; + char *ptr; + size_t Mlen; + struct stat statbuf; + /// "Не задано имя файла!" + if(!filename){ + WARNX(_("No filename given!")); + return NULL; + } + if((fd = open(filename, O_RDONLY)) < 0){ + /// "Не могу открыть %s для чтения" + WARN(_("Can't open %s for reading"), filename); + return NULL; + } + if(fstat (fd, &statbuf) < 0){ + /// "Не могу выполнить stat %s" + WARN(_("Can't stat %s"), filename); + close(fd); + return NULL; + } + Mlen = statbuf.st_size; + if((ptr = mmap (0, Mlen, PROT_READ, MAP_PRIVATE, fd, 0)) == MAP_FAILED){ + /// "Ошибка mmap" + WARN(_("Mmap error for input")); + close(fd); + return NULL; + } + /// "Не могу закрыть mmap'нутый файл" + if(close(fd)) WARN(_("Can't close mmap'ed file")); + mmapbuf *ret = MALLOC(mmapbuf, 1); + ret->data = ptr; + ret->len = Mlen; + return ret; +} + +void My_munmap(mmapbuf *b){ + if(munmap(b->data, b->len)){ + /// "Не могу munmap" + ERR(_("Can't munmap")); + } + FREE(b); +} + + +/******************************************************************************\ + * Terminal in no-echo mode +\******************************************************************************/ +static struct termios oldt, newt; // terminal flags +static int console_changed = 0; +// run on exit: +void restore_console(){ + if(console_changed) + tcsetattr(STDIN_FILENO, TCSANOW, &oldt); // return terminal to previous state + console_changed = 0; +} + +// initial setup: +void setup_con(){ + if(console_changed) return; + tcgetattr(STDIN_FILENO, &oldt); + newt = oldt; + newt.c_lflag &= ~(ICANON | ECHO); + if(tcsetattr(STDIN_FILENO, TCSANOW, &newt) < 0){ + /// "Не могу настроить консоль" + WARN(_("Can't setup console")); + tcsetattr(STDIN_FILENO, TCSANOW, &oldt); + signals(0); //quit? + } + console_changed = 1; +} + +/** + * Read character from console without echo + * @return char readed + */ +int read_console(){ + int rb; + struct timeval tv; + int retval; + fd_set rfds; + FD_ZERO(&rfds); + FD_SET(STDIN_FILENO, &rfds); + tv.tv_sec = 0; tv.tv_usec = 10000; + retval = select(1, &rfds, NULL, NULL, &tv); + if(!retval) rb = 0; + else { + if(FD_ISSET(STDIN_FILENO, &rfds)) rb = getchar(); + else rb = 0; + } + return rb; +} + +/** + * getchar() without echo + * wait until at least one character pressed + * @return character readed + */ +int mygetchar(){ // getchar() without need of pressing ENTER + int ret; + do ret = read_console(); + while(ret == 0); + return ret; +} + + +/******************************************************************************\ + * TTY with select() +\******************************************************************************/ +static struct termio oldtty, tty; // TTY flags +static int comfd = -1; // TTY fd + +// run on exit: +void restore_tty(){ + if(comfd == -1) return; + ioctl(comfd, TCSANOW, &oldtty ); // return TTY to previous state + close(comfd); + comfd = -1; +} + +#ifndef BAUD_RATE +#define BAUD_RATE B4800 +#endif +// init: +void tty_init(char *comdev){ + DBG("\nOpen port...\n"); + if ((comfd = open(comdev,O_RDWR|O_NOCTTY|O_NONBLOCK)) < 0){ + WARN("Can't use port %s\n",comdev); + ioctl(comfd, TCSANOW, &oldtty); // return TTY to previous state + close(comfd); + signals(0); // quit? + } + DBG(" OK\nGet current settings... "); + if(ioctl(comfd,TCGETA,&oldtty) < 0){ // Get settings + /// "Не могу получить настройки" + WARN(_("Can't get settings")); + signals(0); + } + tty = oldtty; + tty.c_lflag = 0; // ~(ICANON | ECHO | ECHOE | ISIG) + tty.c_oflag = 0; + tty.c_cflag = BAUD_RATE|CS8|CREAD|CLOCAL; // 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){ + /// "Не могу установить настройки" + WARN(_("Can't set settings")); + signals(0); + } + DBG(" 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(uint8_t *buff, size_t length){ + ssize_t L = 0, l; + uint8_t *ptr = buff; + fd_set rfds; + struct timeval tv; + int retval; + do{ + l = 0; + FD_ZERO(&rfds); + FD_SET(comfd, &rfds); + // wait for 100ms + tv.tv_sec = 0; tv.tv_usec = 100000; + retval = select(comfd + 1, &rfds, NULL, NULL, &tv); + if (!retval) break; + if(FD_ISSET(comfd, &rfds)){ + if((l = read(comfd, ptr, length)) < 1){ + WARN("read()"); + return 0; + } + + ptr += l; L += l; + length -= l; + } + }while(l); + return (size_t)L; +} + +int write_tty(uint8_t *buff, size_t length){ + ssize_t L = write(comfd, buff, length); + if((size_t)L != length){ + /// "Ошибка записи!" + WARN("Write error!"); + return 1; + } + return 0; +} + + +/** + * Safely convert data from string to double + * + * @param num (o) - double number read from string + * @param str (i) - input string + * @return 1 if success, 0 if fails + */ +int str2double(double *num, const char *str){ + double res; + char *endptr; + if(!str) return 0; + res = strtod(str, &endptr); + if(endptr == str || *str == '\0' || *endptr != '\0'){ + /// "Неправильный формат числа double!" + WARNX("Wrong double number format!"); + return FALSE; + } + if(num) *num = res; // you may run it like myatod(NULL, str) to test wether str is double number + return TRUE; +} diff --git a/usefull_macros.h b/usefull_macros.h new file mode 100644 index 0000000..5f80b9f --- /dev/null +++ b/usefull_macros.h @@ -0,0 +1,138 @@ +/* + * usefull_macros.h - a set of usefull macros: memory, color etc + * + * Copyright 2013 Edward V. Emelianoff + * + * 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 __USEFULL_MACROS_H__ +#define __USEFULL_MACROS_H__ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#if defined GETTEXT_PACKAGE && defined LOCALEDIR +/* + * GETTEXT + */ +#include +#define _(String) gettext(String) +#define gettext_noop(String) String +#define N_(String) gettext_noop(String) +#else +#define _(String) (String) +#define N_(String) (String) +#endif +#include +#include +#include +#include +#include +#include + + +// unused arguments with -Wall -Werror +#define _U_ __attribute__((__unused__)) + +/* + * Coloured messages output + */ +#define RED "\033[1;31;40m" +#define GREEN "\033[1;32;40m" +#define OLDCOLOR "\033[0;0;0m" + +#ifndef FALSE +#define FALSE (0) +#endif + +#ifndef TRUE +#define TRUE (1) +#endif + +/* + * ERROR/WARNING messages + */ +extern int globErr; +extern void signals(int sig); +#define ERR(...) do{globErr=errno; _WARN(__VA_ARGS__); signals(9);}while(0) +#define ERRX(...) do{globErr=0; _WARN(__VA_ARGS__); signals(9);}while(0) +#define WARN(...) do{globErr=errno; _WARN(__VA_ARGS__);}while(0) +#define WARNX(...) do{globErr=0; _WARN(__VA_ARGS__);}while(0) + +/* + * print function name, debug messages + * debug mode, -DEBUG + */ +#ifdef EBUG + #define FNAME() fprintf(stderr, "\n%s (%s, line %d)\n", __func__, __FILE__, __LINE__) + #define DBG(...) do{fprintf(stderr, "%s (%s, line %d): ", __func__, __FILE__, __LINE__); \ + fprintf(stderr, __VA_ARGS__); \ + fprintf(stderr, "\n");} while(0) +#else + #define FNAME() do{}while(0) + #define DBG(...) do{}while(0) +#endif //EBUG + +/* + * Memory allocation + */ +#define ALLOC(type, var, size) type * var = ((type *)my_alloc(size, sizeof(type))) +#define MALLOC(type, size) ((type *)my_alloc(size, sizeof(type))) +#define FREE(ptr) do{if(ptr){free(ptr); ptr = NULL;}}while(0) + +#ifndef DBL_EPSILON +#define DBL_EPSILON (2.2204460492503131e-16) +#endif + +double dtime(); + +// functions for color output in tty & no-color in pipes +extern int (*red)(const char *fmt, ...); +extern int (*_WARN)(const char *fmt, ...); +extern int (*green)(const char *fmt, ...); +void * my_alloc(size_t N, size_t S); +void initial_setup(); + +// mmap file +typedef struct{ + char *data; + size_t len; +} mmapbuf; +mmapbuf *My_mmap(char *filename); +void My_munmap(mmapbuf *b); + +void restore_console(); +void setup_con(); +int read_console(); +int mygetchar(); + +void restore_tty(); +void tty_init(char *comdev); +size_t read_tty(uint8_t *buff, size_t length); +int write_tty(uint8_t *buff, size_t length); + +int str2double(double *num, const char *str); + +#endif // __USEFULL_MACROS_H__