a lot of fixes

This commit is contained in:
2026-11-17 09:21:59 +03:00
parent 58a489f1ad
commit c8ee17854d
15 changed files with 316 additions and 173 deletions

2
.gitignore vendored
View File

@@ -4,3 +4,5 @@
*.o *.o
.hg* .hg*
.dropbox.attr .dropbox.attr
.qtc-clangd
.qtcreator

View File

@@ -12,5 +12,5 @@ getinputs : A02.12 # read discrete input terminal state
getoutputs : A02.13 # read discrete output terminal state getoutputs : A02.13 # read discrete output terminal state
setoutputs : 0x300A # write virtual discrete outputs bitmask setoutputs : 0x300A # write virtual discrete outputs bitmask
state1 : 0x6000 # 1 - cw, 2 - ccw, 3 - stop, 4 - damage, 5 - low voltage state1 : 0x6000 # 1 - cw, 2 - ccw, 3 - stop, 4 - damage, 5 - low voltage
state2 : # bits: 0 - ready (0), 1,2 - motor No, 3 - async (0), 4 - alarm overloading (0), 5,6 - keypad (0), 485 (10) #state2 : # bits: 0 - ready (0), 1,2 - motor No, 3 - async (0), 4 - alarm overloading (0), 5,6 - keypad (0), 485 (10)
errcode : 0x6002 # last error code errcode : 0x6002 # last error code

View File

@@ -5,7 +5,7 @@ LDFLAGS += -lusefull_macros -lmodbus
SRCS := $(wildcard *.c) SRCS := $(wildcard *.c)
DEFINES := $(DEF) -D_GNU_SOURCE -D_XOPEN_SOURCE=1111 DEFINES := $(DEF) -D_GNU_SOURCE -D_XOPEN_SOURCE=1111
OBJDIR := mk OBJDIR := mk
CFLAGS += -O2 -Wall -Wextra -Wno-trampolines CFLAGS += -O2 -Wall -Wextra -Wno-trampolines -std=gnu23
OBJS := $(addprefix $(OBJDIR)/, $(SRCS:%.c=%.o)) OBJS := $(addprefix $(OBJDIR)/, $(SRCS:%.c=%.o))
DEPS := $(OBJS:.o=.d) DEPS := $(OBJS:.o=.d)
TARGFILE := $(OBJDIR)/TARGET TARGFILE := $(OBJDIR)/TARGET

View File

@@ -61,37 +61,40 @@ modbus_params [options]
| Option | Argument | Description | | Option | Argument | Description |
|--------|-------------------|-------------| |--------|-------------------|-------------|
| `-h`, `--help` | – | Show help and exit |
| `-v`, `--verbose` | – | Increase verbosity (can be used multiple times) |
| `-D`, `--dictionary` | *file* | Dictionary file (format: `code register value readonly`). *Required for most operations.* |
| `-a`, `--alias` | *file* | Aliases file (format: `name : command`). Optional. | | `-a`, `--alias` | *file* | Aliases file (format: `name : command`). Optional. |
| `-s`, `--slave` | *ID* | Modbus slave ID (default: 1) |
| `-d`, `--device` | *path* | Serial device (default: `/dev/ttyUSB0`) |
| `-b`, `--baudrate` | *rate* | Baud rate (default: 9600) | | `-b`, `--baudrate` | *rate* | Baud rate (default: 9600) |
| `-d`, `--device` | *path* | Serial device (default: `/dev/ttyUSB0`) |
| `-D`, `--dictionary` | *file* | Dictionary file (format: `code register value readonly`). *Required for most operations.* |
| `-f`, `--format` | *fmt* | Serial port format: databitss parity stopbits (default: "8N1") |
| `-h`, `--help` | – | Show help and exit |
| `-s`, `--slave` | *ID* | Modbus slave ID (default: 1) |
| `-v`, `--verbose` | – | Increase verbosity (can be used multiple times) |
### Read/write operations ### Read/write operations
| Option | Description | | Option | Description |
|--------|-------------| |--------|-------------|
| `-C`, `--clone` | Write all read-write entries of the `-D` dictionary to the device. Read-only entries are skipped. On completion prints written N, errors M.|
| `-O`, `--outdic` *file* | Read **all** registers listed in the dictionary and save them (with current values) into a new dictionary file |
| `-r`, `--readr` *addr* | Read register by address (multiply: `-r 100 -r 200`) | | `-r`, `--readr` *addr* | Read register by address (multiply: `-r 100 -r 200`) |
| `-R`, `--readc` *code* | Read register by dictionary code (multiply) | | `-R`, `--readc` *code* | Read register by dictionary code (multiply) |
| `-w`, `--writer` *addr=val* | Write value to register by address (multiply) | | `-w`, `--writer` *addr=val* | Write value to register by address (multiply) |
| `-W`, `--writec` *code=val* | Write value to register by dictionary code (multiply) | | `-W`, `--writec` *code=val* | Write value to register by dictionary code (multiply) |
| `-O`, `--outdic` *file* | Read **all** registers listed in the dictionary and save them (with current values) into a new dictionary file |
### Discrete I/O sizes ### Discrete I/O sizes
| Option | Argument | Description | | Option | Argument | Description |
|--------|-------------------|-------------| |--------|-------------------|-------------|
| `-i`, `--inputs` | N | Number of bytes for discrete inputs (default: 1) |
| `-c`, `--coils` | N | Number of bytes for coils/outputs (default: 1) | | `-c`, `--coils` | N | Number of bytes for coils/outputs (default: 1) |
| `-i`, `--inputs` | N | Number of bytes for discrete inputs (default: 1) |
### Dumping (periodic TSV output) ### Dumping (periodic TSV output)
| Option | Description | | Option | Description |
|--------|-------------| |--------|-------------|
| `-k`, `--dumpkey` *code* | Add a dictionary key to the dump list (multiply) | | `-k`, `--dumpkey` *code* | Add a dictionary key to the dump list (multiply) |
| `-o`, `--outfile` *file* | TSV file for the dump | | `-o`, `--outfile` *file* | TSV file for the dump (path relative to `/tmp/`) |
| `-t`, `--dumptime` *seconds* | Dump interval (default: 0.1 s) | | `-t`, `--dumptime` *seconds* | Dump interval (default: 0.1 s) |
### Server mode ### Server mode
@@ -120,7 +123,7 @@ Format:
- `value` – initial/default value (16‑bit, not used by the tool except for documentation). - `value` – initial/default value (16‑bit, not used by the tool except for documentation).
- `readonly` – `0` (writable) or `1` (read‑only). - `readonly` – `0` (writable) or `1` (read‑only).
Example (from `dictionary.dic`): Example (from `ESQ770.dic`):
``` ```
F00.00 61440 1 0 # Motor management (V/F) F00.00 61440 1 0 # Motor management (V/F)
@@ -169,6 +172,8 @@ Example:
0.102 1 5000 0.102 1 5000
``` ```
For sequrity reasons dump file name is relative to `/tmp` and shouldn't have `../` inside.
## Server protocol ## Server protocol
The server listens for plain text commands, terminated by newline (`\n`). The server listens for plain text commands, terminated by newline (`\n`).
@@ -260,19 +265,19 @@ readinputs[0] = 1
### 1. Simple read by address ### 1. Simple read by address
```bash ```bash
modbus_params -D dictionary.txt -s 1 -d /dev/ttyUSB0 -b 9600 -r 61440 modbus_params -D dictionary.dic -s 1 -d /dev/ttyUSB0 -b 9600 -r 61440
``` ```
### 2. Write a value using a code ### 2. Write a value using a code
```bash ```bash
modbus_params -D dictionary.txt -W "F00.00=1" modbus_params -D dictionary.dic -W "F00.00=1"
``` ```
### 3. Dump two registers every 0.5 seconds to `data.tsv` ### 3. Dump two registers every 0.5 seconds to `data.tsv`
```bash ```bash
modbus_params -D dictionary.txt -k F00.00 -k F00.11 -o data.tsv -t 0.5 modbus_params -D dictionary.dic -k F00.00 -k F00.11 -o data.tsv -t 0.5
``` ```
(No server started – the program will dump until interrupted.) (No server started – the program will dump until interrupted.)
@@ -280,7 +285,7 @@ modbus_params -D dictionary.txt -k F00.00 -k F00.11 -o data.tsv -t 0.5
### 4. Start a local server with dumping already active ### 4. Start a local server with dumping already active
```bash ```bash
modbus_params -D dictionary.txt -k F00.00 -o /tmp/dump.csv -t 1 -N localhost:5020 modbus_params -D dictionary.dic -k F00.00 -o /tmp/dump.csv -t 1 -N localhost:5020
``` ```
Now you can connect to port 5020 and use `newdump` to change the output file, or `clodump` to stop. Now you can connect to port 5020 and use `newdump` to change the output file, or `clodump` to stop.

View File

@@ -55,19 +55,31 @@ size_t get_aliasessize(){ return aliasessize; }
// functions for `qsort` (`needle` and `straw` are pointers to pointers) // functions for `qsort` (`needle` and `straw` are pointers to pointers)
static int sort_by_code(const void *needle, const void *straw){ static int sort_by_code(const void *needle, const void *straw){
if(!needle && !straw) return 0;
if(!needle) return -1;
if(!straw) return 1;
const char *c1 = (*(dicentry_t**)needle)->code, *c2 = (*(dicentry_t**)straw)->code; const char *c1 = (*(dicentry_t**)needle)->code, *c2 = (*(dicentry_t**)straw)->code;
return strcmp(c1, c2); return strcmp(c1, c2);
} }
static int sort_by_reg(const void *needle, const void *straw){ static int sort_by_reg(const void *needle, const void *straw){
if(!needle && !straw) return 0;
if(!needle) return -1;
if(!straw) return 1;
const int r1 = (int)(*(dicentry_t**)needle)->reg, r2 = (int)(*(dicentry_t**)straw)->reg; const int r1 = (int)(*(dicentry_t**)needle)->reg, r2 = (int)(*(dicentry_t**)straw)->reg;
return r1 - r2; return r1 - r2;
} }
// functions for `binsearch` // functions for `binsearch`
static int search_by_code(const void *code, const void *straw){ static int search_by_code(const void *code, const void *straw){
if(!code && !straw) return 0;
if(!code) return -1;
if(!straw) return 1;
const char *c1 = (const char*)code, *c2 = ((dicentry_t*)straw)->code; const char *c1 = (const char*)code, *c2 = ((dicentry_t*)straw)->code;
return strcmp(c1, c2); return strcmp(c1, c2);
} }
static int search_by_reg(const void *reg, const void *straw){ static int search_by_reg(const void *reg, const void *straw){
if(!reg && !straw) return 0;
if(!reg) return -1;
if(!straw) return 1;
const int r1 = (int)(*(uint16_t*)reg), r2 = (int)((dicentry_t*)straw)->reg; const int r1 = (int)(*(uint16_t*)reg), r2 = (int)((dicentry_t*)straw)->reg;
return r1 - r2; return r1 - r2;
} }
@@ -92,14 +104,14 @@ static char *getcomment(char *str){
// all after "#" is comment; // all after "#" is comment;
// dictionary format: "'code' 'register' 'value' 'readonly flag'\n", e.g. // dictionary format: "'code' 'register' 'value' 'readonly flag'\n", e.g.
// "F00.09 61444 5000 1" // "F00.09 61444 5000 1"
int opendict(const char *dic){ bool opendict(const char *dic){
if(!dic) return FALSE; if(!dic || !*dic) return false;
DBG("Open %s", dic); DBG("Open %s", dic);
closedict(); // close early opened dictionary to prevent problems closedict(); // close early opened dictionary to prevent problems
FILE *f = fopen(dic, "r"); FILE *f = fopen(dic, "r");
if(!f){ if(!f){
WARN("Can't open %s", dic); WARN("Can't open %s", dic);
return FALSE; return false;
} }
size_t dicsz = 0; size_t dicsz = 0;
size_t linesz = BUFSIZ; size_t linesz = BUFSIZ;
@@ -107,7 +119,7 @@ int opendict(const char *dic){
dicentry_t curentry; dicentry_t curentry;
curentry.code = MALLOC(char, BUFSIZ); curentry.code = MALLOC(char, BUFSIZ);
// `help` field of `curentry` isn't used here // `help` field of `curentry` isn't used here
int retcode = TRUE; bool retcode = true;
char formatbuf[64]; char formatbuf[64];
snprintf(formatbuf, 64, "%%%ds %%" SCNu16 " %%" SCNu16 " %%" SCNu8, BUFSIZ-1); snprintf(formatbuf, 64, "%%%ds %%" SCNu16 " %%" SCNu16 " %%" SCNu8, BUFSIZ-1);
while(1){ while(1){
@@ -123,21 +135,26 @@ int opendict(const char *dic){
WARNX("Can't understand this line: '%s'", line); WARNX("Can't understand this line: '%s'", line);
continue; continue;
} }
DBG("Got line: '%s %" PRIu16 " %" PRIu16 " %" PRIu8, curentry.code, curentry.reg, curentry.value, curentry.readonly); DBG("Got line: '%s %" PRIu16 " %" PRIu16 " %" PRIu8, curentry.code, curentry.reg, curentry.value, curentry.readonly);
if(++dictsize >= dicsz){ if(++dictsize >= dicsz){
size_t newsize = dicsz + 50; size_t newsize = dicsz + 50;
dicentry_t *newdic = realloc(dictionary, sizeof(dicentry_t) * newsize); dicentry_t *newdic = realloc(dictionary, sizeof(dicentry_t) * newsize);
if(!newdic){ if(!newdic){
WARN("Can't allocate memory for dictionary"); retcode = false;
retcode = FALSE;
--dictsize; --dictsize;
goto ret; WARN("Can't allocate memory for dictionary; got only %zd entries", dictsize);
break;
} }
dictionary = newdic; dictionary = newdic;
dicsz = newsize; dicsz = newsize;
} }
dicentry_t *entry = &dictionary[dictsize-1]; dicentry_t *entry = &dictionary[dictsize-1];
entry->code = strdup(curentry.code); entry->code = strdup(curentry.code);
if(!entry->code){
WARN("strdup()");
--dictsize;
continue;
}
entry->reg = curentry.reg; entry->reg = curentry.reg;
entry->value = curentry.value; entry->value = curentry.value;
entry->readonly = curentry.readonly; entry->readonly = curentry.readonly;
@@ -146,13 +163,14 @@ int opendict(const char *dic){
//DBG("Add entry; now dictsize is %d", dictsize); //DBG("Add entry; now dictsize is %d", dictsize);
} }
// init dictionaries for sort // init dictionaries for sort
dictbycode = MALLOC(dicentry_t*, dictsize); if(dictsize > 0){
dictbyreg = MALLOC(dicentry_t*, dictsize); dictbycode = MALLOC(dicentry_t*, dictsize);
for(size_t i = 0; i < dictsize; ++i) dictbyreg = MALLOC(dicentry_t*, dictsize);
dictbyreg[i] = dictbycode[i] = &dictionary[i]; for(size_t i = 0; i < dictsize; ++i)
qsort(dictbycode, dictsize, sizeof(dicentry_t*), sort_by_code); dictbyreg[i] = dictbycode[i] = &dictionary[i];
qsort(dictbyreg, dictsize, sizeof(dicentry_t*), sort_by_reg); qsort(dictbycode, dictsize, sizeof(dicentry_t*), sort_by_code);
ret: qsort(dictbyreg, dictsize, sizeof(dicentry_t*), sort_by_reg);
}
fclose(f); fclose(f);
FREE(curentry.code); FREE(curentry.code);
FREE(line); FREE(line);
@@ -163,12 +181,12 @@ ret:
* @brief chkdict - check if dictionary is opened * @brief chkdict - check if dictionary is opened
* @return TRUE if dictionary opened * @return TRUE if dictionary opened
*/ */
int chkdict(){ bool chkdict(){
if(dictsize < 1){ if(dictsize < 1){
WARNX("Init dictionary first"); WARNX("Init dictionary first");
return FALSE; return false;
} }
return TRUE; return true;
} }
void closedict(){ void closedict(){
@@ -210,15 +228,14 @@ dicentry_t *findentry_by_code(const char *code){
dicentry_t *findentry_by_reg(uint16_t reg){ dicentry_t *findentry_by_reg(uint16_t reg){
if(!chkdict()) return NULL; if(!chkdict()) return NULL;
return binsearch(dictbyreg, (const void*)(&reg), search_by_reg); return binsearch(dictbyreg, (const void*)(&reg), search_by_reg);
return NULL;
} }
/** dump functions **/ /** dump functions (thread-unsafe!) **/
// prepare a list with dump parameters (new call will rewrite previous list) // prepare a list with dump parameters (new call will rewrite previous list)
int setdumppars(char **pars){ bool setdumppars(char **pars){
if(!pars || !*pars) return FALSE; if(!pars || !*pars) return false;
if(!chkdict()) return FALSE; if(!chkdict()) return false;
FNAME(); FNAME();
char **p = pars; char **p = pars;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
@@ -231,7 +248,7 @@ int setdumppars(char **pars){
WARNX("Can't find entry with code %s", *p); WARNX("Can't find entry with code %s", *p);
pthread_mutex_unlock(&mutex); pthread_mutex_unlock(&mutex);
dumpsize = 0; dumpsize = 0;
return FALSE; return false;
} }
DBG("found entry do dump, reg=%d", e->reg); DBG("found entry do dump, reg=%d", e->reg);
if(cursz <= N){ if(cursz <= N){
@@ -241,7 +258,7 @@ int setdumppars(char **pars){
if(!newpars){ if(!newpars){
WARN("realloc()"); WARN("realloc()");
pthread_mutex_unlock(&mutex); pthread_mutex_unlock(&mutex);
return FALSE; return false;
}else{ }else{
dumppars = newpars; dumppars = newpars;
cursz = newsz; cursz = newsz;
@@ -254,45 +271,53 @@ int setdumppars(char **pars){
dumppars[N] = *e; dumppars[N] = *e;
dumppars[N].code = strdup(e->code); dumppars[N].code = strdup(e->code);
if(e->help) dumppars[N].help = strdup(e->help); if(e->help) dumppars[N].help = strdup(e->help);
else dumppars[N].help = NULL;
DBG("Add %s", e->code); DBG("Add %s", e->code);
++N; ++p; ++N; ++p;
} }
dumpsize = N; dumpsize = N;
pthread_mutex_unlock(&mutex); pthread_mutex_unlock(&mutex);
return TRUE; return true;
} }
// open dump file and add header; return FALSE if failed // open dump file (path relative to "/tmp") and add header; return FALSE if failed
int opendumpfile(const char *name){ bool opendumpfile(const char *name){
if(!chkdict()) return FALSE; if(!chkdict()) return false;
if(dumpsize < 1){ if(dumpsize < 1){
WARNX("Set dump parameters first"); WARNX("Set dump parameters first");
return FALSE; return false;
} }
if(!name) return FALSE; if(!name || !*name) return false;
if(strstr(name, "../")) return false; // don't allow change to upper level
closedumpfile(); closedumpfile();
dumpfile = fopen(name, "w+"); char path[PATH_MAX];
ssize_t L;
if(*name == '/') L = snprintf(path, PATH_MAX-1, "/tmp%s", name);
else L = snprintf(path, PATH_MAX-1, "/tmp/%s", name);
if(L < 1) return false;
if(L >= PATH_MAX-1) path[PATH_MAX-1] = 0;
dumpfile = fopen(path, "w+");
if(!dumpfile){ if(!dumpfile){
WARN("Can't open %s", name); WARN("Can't open %s", path);
return FALSE; return false;
} }
dumpname = strdup(name); dumpname = strdup(path);
fprintf(dumpfile, "# time,s "); fprintf(dumpfile, "# time,s ");
for(int i = 0; i < dumpsize; ++i){ for(int i = 0; i < dumpsize; ++i){
fprintf(dumpfile, "%s ", dumppars[i].code); fprintf(dumpfile, "%s ", dumppars[i].code);
} }
fprintf(dumpfile, "\n"); fprintf(dumpfile, "\n");
return TRUE; return true;
} }
char *getdumpname(){ return dumpname;} const char *getdumpname(){ return dumpname;}
void closedumpfile(){ void closedumpfile(){
int stpd = atomic_load(&isstopped); int stpd = atomic_load(&isstopped);
if(dumpfile){ if(dumpfile){
if(!stpd){ if(!stpd){
atomic_store(&stopdump, 1); atomic_store(&stopdump, 1);
while(!atomic_load(&isstopped)); while(!atomic_load(&isstopped)) usleep(1000);
} }
fclose(dumpfile); fclose(dumpfile);
dumpfile = NULL; dumpfile = NULL;
@@ -320,29 +345,30 @@ static void *dumpthread(void *p){
return NULL; return NULL;
} }
int setDumpT(double dT){ bool setDumpT(double dT){
if(dT < 0.){ if(dT < 0. || dT > 60.){
WARNX("Time interval should be > 0"); WARNX("Time interval should be > 0 and <= 60.");
return FALSE; return false;
} }
dumpTime = dT; dumpTime = dT;
DBG("user give dT: %g", dT); DBG("user give dT: %g", dT);
return TRUE; return true;
} }
int rundump(){ bool rundump(){
if(!dumpfile){ if(!dumpfile){
WARNX("Open dump file first"); WARNX("Open dump file first");
return FALSE; return false;
} }
pthread_t thread; pthread_t thread;
if(pthread_create(&thread, NULL, dumpthread, (void*)&dumpTime)){ if(pthread_create(&thread, NULL, dumpthread, (void*)&dumpTime)){
WARN("Can't create dumping thread"); WARN("Can't create dumping thread");
return FALSE; return false;
} }
while(atomic_load(&isstopped)) usleep(1000); // wait until thread starts
DBG("Thread created, detach"); DBG("Thread created, detach");
pthread_detach(thread); pthread_detach(thread);
return TRUE; return true;
} }
/** /**
@@ -356,7 +382,7 @@ int rundump(){
char *dicentry_descr(dicentry_t *entry, char *buf, size_t bufsize){ char *dicentry_descr(dicentry_t *entry, char *buf, size_t bufsize){
//DBG("descr of %s", entry->code); //DBG("descr of %s", entry->code);
if(!entry || !buf || !bufsize) return NULL; if(!entry || !buf || !bufsize) return NULL;
size_t L; ssize_t L;
if(entry->help){ if(entry->help){
L = snprintf(buf, bufsize, "%s %4" PRIu16 " %4" PRIu16 " %" PRIu8 " # %s\n", L = snprintf(buf, bufsize, "%s %4" PRIu16 " %4" PRIu16 " %" PRIu8 " # %s\n",
entry->code, entry->reg, entry->value, entry->readonly, entry->help); entry->code, entry->reg, entry->value, entry->readonly, entry->help);
@@ -364,7 +390,8 @@ char *dicentry_descr(dicentry_t *entry, char *buf, size_t bufsize){
L = snprintf(buf, bufsize, "%s %4" PRIu16 " %4" PRIu16 " %" PRIu8 "\n", L = snprintf(buf, bufsize, "%s %4" PRIu16 " %4" PRIu16 " %" PRIu8 "\n",
entry->code, entry->reg, entry->value, entry->readonly); entry->code, entry->reg, entry->value, entry->readonly);
} }
if(L >= bufsize) buf[bufsize-1] = 0; if(L < 1) return NULL;
else if(L >= (ssize_t)bufsize) buf[bufsize-1] = 0;
return buf; return buf;
} }
@@ -375,7 +402,7 @@ char *dicentry_descrN(size_t N, char *buf, size_t bufsize){
// dump all registers by input dictionary into output; also modify values of registers in dictionary // dump all registers by input dictionary into output; also modify values of registers in dictionary
int read_dict_entries(const char *outdic){ int read_dict_entries(const char *outdic){
if(!chkdict()) return -1; if(!outdic || !chkdict()) return -1;
int got = 0; int got = 0;
FILE *o = fopen(outdic, "w"); FILE *o = fopen(outdic, "w");
if(!o){ if(!o){
@@ -388,7 +415,7 @@ int read_dict_entries(const char *outdic){
verbose(LOGLEVEL_MSG, "Read register %d, value: %d\n", dictionary[i].reg, dictionary[i].value); verbose(LOGLEVEL_MSG, "Read register %d, value: %d\n", dictionary[i].reg, dictionary[i].value);
if(dicentry_descrN(i, buf, BUFSIZ)){ if(dicentry_descrN(i, buf, BUFSIZ)){
++got; ++got;
fprintf(o, "%s\n", buf); fprintf(o, "%s", buf);
} }
}else verbose(LOGLEVEL_WARN, "Can't read value of register %d\n", dictionary[i].reg); }else verbose(LOGLEVEL_WARN, "Can't read value of register %d\n", dictionary[i].reg);
} }
@@ -396,6 +423,35 @@ int read_dict_entries(const char *outdic){
return got; return got;
} }
/**
* @brief write_dict_entries - write all read-write dictionary entries to device
* @param errors - out: number of failed writes (may be NULL)
* @return number of successfully written entries, or -1 if dictionary isn't opened
*
* Entries with `readonly != 0` are skipped silently (not counted as errors).
*/
int write_dict_entries(int *errors){
if(errors) *errors = 0;
if(!chkdict()) return -1;
int written = 0, failed = 0;
for(size_t i = 0; i < dictsize; ++i){
dicentry_t *e = &dictionary[i];
if(e->readonly) continue; // read-only => skip, not an error
if(write_entry(e)){
verbose(LOGLEVEL_MSG, "Wrote %u to register %u (%s)\n",
e->value, e->reg, e->code);
++written;
}else{
// write_entry() already emitted WARNX with details;
// add context with mnemonic code
verbose(LOGLEVEL_WARN, "Can't write %u to register %u (%s)\n",
e->value, e->reg, e->code);
++failed;
}
}
if(errors) *errors = failed;
return written;
}
/********** Aliases **********/ /********** Aliases **********/
@@ -415,14 +471,15 @@ static int sortalias(const void *l, const void *r){
} }
// open file with aliases and fill structure // open file with aliases and fill structure
int openaliases(const char *filename){ bool openaliases(const char *filename){
closealiases(); if(!filename) return false;
FILE *f = fopen(filename, "r"); FILE *f = fopen(filename, "r");
if(!f){ if(!f){
WARN("Can't open %s", filename); WARN("Can't open %s", filename);
return FALSE; return false;
} }
int retcode = TRUE; closealiases();
int retcode = true;
size_t linesz = BUFSIZ, asz = 0; size_t linesz = BUFSIZ, asz = 0;
char *line = MALLOC(char, linesz); char *line = MALLOC(char, linesz);
while(1){ while(1){
@@ -457,7 +514,7 @@ int openaliases(const char *filename){
alias_t *newaliases = realloc(aliases, sizeof(alias_t) * newsize); alias_t *newaliases = realloc(aliases, sizeof(alias_t) * newsize);
if(!newaliases){ if(!newaliases){
WARNX("Can't allocate memory for aliases list"); WARNX("Can't allocate memory for aliases list");
retcode = FALSE; retcode = false;
--aliasessize; --aliasessize;
goto ret; goto ret;
} }
@@ -471,7 +528,7 @@ int openaliases(const char *filename){
else cur->help = NULL; else cur->help = NULL;
DBG("Read alias; name='%s', expr='%s', comment='%s'", cur->name, cur->expr, cur->help); DBG("Read alias; name='%s', expr='%s', comment='%s'", cur->name, cur->expr, cur->help);
} }
if(aliasessize == 0) retcode = FALSE; if(aliasessize == 0) retcode = false;
qsort(aliases, aliasessize, sizeof(alias_t), sortalias); qsort(aliases, aliasessize, sizeof(alias_t), sortalias);
ret: ret:
fclose(f); fclose(f);
@@ -480,12 +537,12 @@ ret:
} }
// return TRUE if aliases list inited // return TRUE if aliases list inited
int chkaliases(){ bool chkaliases(){
if(aliasessize < 1){ if(aliasessize < 1){
WARNX("Init aliases first"); WARNX("Init aliases first");
return FALSE; return false;
} }
return TRUE; return true;
} }
// remove aliases // remove aliases
void closealiases(){ void closealiases(){

View File

@@ -35,9 +35,9 @@ typedef struct{
char *help; // help message char *help; // help message
} alias_t; } alias_t;
int opendict(const char *dic); bool opendict(const char *dic);
void closedict(); void closedict();
int chkdict(); bool chkdict();
size_t get_dictsize(); size_t get_dictsize();
char *dicentry_descr(dicentry_t *entry, char *buf, size_t bufsize); char *dicentry_descr(dicentry_t *entry, char *buf, size_t bufsize);
char *dicentry_descrN(size_t N, char *buf, size_t bufsize); char *dicentry_descrN(size_t N, char *buf, size_t bufsize);
@@ -45,17 +45,18 @@ char *dicentry_descrN(size_t N, char *buf, size_t bufsize);
dicentry_t *findentry_by_code(const char *code); dicentry_t *findentry_by_code(const char *code);
dicentry_t *findentry_by_reg(uint16_t reg); dicentry_t *findentry_by_reg(uint16_t reg);
int setdumppars(char **pars); bool setdumppars(char **pars);
int opendumpfile(const char *name); bool opendumpfile(const char *name);
void closedumpfile(); void closedumpfile();
int setDumpT(double dT); bool setDumpT(double dT);
int rundump(); bool rundump();
char *getdumpname(); const char *getdumpname();
int read_dict_entries(const char *outdic); int read_dict_entries(const char *outdic);
int write_dict_entries(int *errors);
int openaliases(const char *filename); bool openaliases(const char *filename);
int chkaliases(); bool chkaliases();
void closealiases(); void closealiases();
size_t get_aliasessize(); size_t get_aliasessize();
alias_t *find_alias(const char *name); alias_t *find_alias(const char *name);

View File

@@ -32,6 +32,7 @@ typedef struct{
int isunix; // Unix-socket int isunix; // Unix-socket
int inputs; // number of bytes for discrete inputs int inputs; // number of bytes for discrete inputs
int coils; // number of bytes for coils int coils; // number of bytes for coils
int clone; // clone dictionary onto device
char **read_keycodes; // keycodes to dump into file char **read_keycodes; // keycodes to dump into file
char **writeregs; // reg=val to write char **writeregs; // reg=val to write
char **writecodes; // keycode=val to write char **writecodes; // keycode=val to write
@@ -43,6 +44,7 @@ typedef struct{
char *aliasesfile; // file with aliases char *aliasesfile; // file with aliases
char *device; // serial device char *device; // serial device
char *node; // server port or path char *node; // server port or path
char *portformat; // serial port format
int baudrate; // baudrate int baudrate; // baudrate
double dTdump; // dumping time interval (s) double dTdump; // dumping time interval (s)
} parameters; } parameters;
@@ -54,6 +56,7 @@ static parameters G = {
.dTdump = 0.1, .dTdump = 0.1,
.inputs = 1, .inputs = 1,
.coils = 1, .coils = 1,
.portformat = "8N1",
}; };
static sl_option_t cmdlnopts[] = { static sl_option_t cmdlnopts[] = {
@@ -66,8 +69,10 @@ static sl_option_t cmdlnopts[] = {
{"slave", NEED_ARG, NULL, 's', arg_int, APTR(&G.slave), "slave ID (default: 1)"}, {"slave", NEED_ARG, NULL, 's', arg_int, APTR(&G.slave), "slave ID (default: 1)"},
{"device", NEED_ARG, NULL, 'd', arg_string, APTR(&G.device), "modbus device (default: /dev/ttyUSB0)"}, {"device", NEED_ARG, NULL, 'd', arg_string, APTR(&G.device), "modbus device (default: /dev/ttyUSB0)"},
{"baudrate", NEED_ARG, NULL, 'b', arg_int, APTR(&G.baudrate), "modbus baudrate (default: 9600)"}, {"baudrate", NEED_ARG, NULL, 'b', arg_int, APTR(&G.baudrate), "modbus baudrate (default: 9600)"},
{"format", NEED_ARG, NULL, 'f', arg_string, APTR(&G.portformat),"serial port format (default: 8N1)"},
{"writer", MULT_PAR, NULL, 'w', arg_string, APTR(&G.writeregs), "write new value to register (format: reg=val); multiply parameter"}, {"writer", MULT_PAR, NULL, 'w', arg_string, APTR(&G.writeregs), "write new value to register (format: reg=val); multiply parameter"},
{"writec", MULT_PAR, NULL, 'W', arg_string, APTR(&G.writecodes),"write new value to register by keycode (format: keycode=val); multiply parameter"}, {"writec", MULT_PAR, NULL, 'W', arg_string, APTR(&G.writecodes),"write new value to register by keycode (format: keycode=val); multiply parameter"},
{"clone", NO_ARGS, NULL, 'C', arg_int, APTR(&G.clone), "write all read-write dictionary entries (from -D) to device"},
{"outdic", NEED_ARG, NULL, 'O', arg_string, APTR(&G.outdic), "output dictionary for full device dump by input dictionary registers"}, {"outdic", NEED_ARG, NULL, 'O', arg_string, APTR(&G.outdic), "output dictionary for full device dump by input dictionary registers"},
{"readr", MULT_PAR, NULL, 'r', arg_int, APTR(&G.readregs), "registers (by address) to read; multiply parameter"}, {"readr", MULT_PAR, NULL, 'r', arg_int, APTR(&G.readregs), "registers (by address) to read; multiply parameter"},
{"readc", MULT_PAR, NULL, 'R', arg_string, APTR(&G.readcodes), "registers (by keycodes, checked by dictionary) to read; multiply parameter"}, {"readc", MULT_PAR, NULL, 'R', arg_string, APTR(&G.readcodes), "registers (by keycodes, checked by dictionary) to read; multiply parameter"},
@@ -79,12 +84,15 @@ static sl_option_t cmdlnopts[] = {
end_option end_option
}; };
static bool isrunning = true;
void signals(int sig){ void signals(int sig){
if(sig > 0) WARNX("Exig with signal %d", sig); if(sig > 0){
close_modbus(); WARNX("Exit with signal %d", sig);
closedict(); signal(sig, SIG_IGN);
closealiases(); }
exit(sig); stop_server();
isrunning = false;
} }
int main(int argc, char **argv){ int main(int argc, char **argv){
@@ -92,8 +100,9 @@ int main(int argc, char **argv){
sl_parseargs(&argc, &argv, cmdlnopts); sl_parseargs(&argc, &argv, cmdlnopts);
if(G.help) sl_showhelp(-1, cmdlnopts); if(G.help) sl_showhelp(-1, cmdlnopts);
sl_loglevel_e lvl = G.verbose + LOGLEVEL_ERR; sl_loglevel_e lvl = G.verbose + LOGLEVEL_ERR;
set_verbose_level(lvl); set_verbose_level(&lvl);
if(lvl >= LOGLEVEL_AMOUNT) lvl = LOGLEVEL_AMOUNT - 1; // here we can also open log-file with given level
if(!G.dicfile) WARNX("Dictionary is absent"); if(!G.dicfile) WARNX("Dictionary is absent");
else if(!opendict(G.dicfile)) signals(-1); else if(!opendict(G.dicfile)) signals(-1);
DBG("dictionary %s opened", G.dicfile); DBG("dictionary %s opened", G.dicfile);
@@ -103,7 +112,7 @@ int main(int argc, char **argv){
if(G.read_keycodes && !setdumppars(G.read_keycodes)) signals(-1); if(G.read_keycodes && !setdumppars(G.read_keycodes)) signals(-1);
if(G.dumpfile) DBG("Dump file: %s", G.dumpfile); if(G.dumpfile) DBG("Dump file: %s", G.dumpfile);
if(G.dumpfile && !opendumpfile(G.dumpfile)) signals(-1); if(G.dumpfile && !opendumpfile(G.dumpfile)) signals(-1);
if(!open_modbus(G.device, G.baudrate)) signals(-1); if(!open_modbus(G.device, G.portformat, G.baudrate)) signals(-1);
if(!set_slave(G.slave)) signals(-1); if(!set_slave(G.slave)) signals(-1);
signal(SIGTERM, signals); // kill (-15) - quit signal(SIGTERM, signals); // kill (-15) - quit
signal(SIGHUP, SIG_IGN); // hup - ignore signal(SIGHUP, SIG_IGN); // hup - ignore
@@ -113,13 +122,23 @@ int main(int argc, char **argv){
if(G.writeregs){ if(G.writeregs){
DBG("writeregs"); DBG("writeregs");
green("Write user registers to slave %d\n", G.slave); green("Write user registers to slave %d\n", G.slave);
green("Total: %d written successfully", write_regval(G.writeregs)); green("Total: %d written successfully\n", write_regval(G.writeregs));
fflush(stdout); fflush(stdout);
} }
if(G.writecodes){ if(G.writecodes){
DBG("writecodes"); DBG("writecodes");
green("Write user registers coded by keycode to slave %d\n", G.slave); green("Write user registers coded by keycode to slave %d\n", G.slave);
green("Total: %d written successfully", write_codeval(G.writecodes)); green("Total: %d written successfully\n", write_codeval(G.writecodes));
fflush(stdout);
}
if(G.clone){
DBG("clone");
green("Write all read-write dictionary entries to slave %d\n", G.slave);
fflush(stdout);
int errors = 0;
int N = write_dict_entries(&errors);
if(N < 0) WARNX("Clone failed: dictionary is not opened");
else green("Clone done: written %d, errors %d\n", N, errors);
fflush(stdout); fflush(stdout);
} }
if(G.outdic){ if(G.outdic){
@@ -140,10 +159,12 @@ int main(int argc, char **argv){
set_io_sizes(G.inputs, G.coils); set_io_sizes(G.inputs, G.coils);
DBG("Create server"); DBG("Create server");
if(!runserver(G.node, G.isunix)) signals(-1); // this function exits only after server death if(!runserver(G.node, G.isunix)) signals(-1); // this function exits only after server death
}else if(G.dumpfile){
green("Dump is running, wait for ctrl+C");
while(isrunning) usleep(100000);
} }
if(G.dumpfile){ close_modbus();
DBG("Done, wait for ctrl+C"); closedict();
while(1) usleep(100000); closealiases();
}
return 0; return 0;
} }

View File

@@ -18,6 +18,7 @@
#include <inttypes.h> #include <inttypes.h>
#include <modbus/modbus.h> #include <modbus/modbus.h>
#include <stdatomic.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <usefull_macros.h> #include <usefull_macros.h>
@@ -29,6 +30,9 @@
#define MAX_READ_BITS 64 #define MAX_READ_BITS 64
#define MAX_WRITE_BITS 64 #define MAX_WRITE_BITS 64
// slave ID
static atomic_int slaveID = 1;
static modbus_t *modbus_ctx = NULL; static modbus_t *modbus_ctx = NULL;
static pthread_mutex_t modbus_mutex = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t modbus_mutex = PTHREAD_MUTEX_INITIALIZER;
@@ -44,35 +48,39 @@ void close_modbus(){
} }
// read register and modify entry->reg; return FALSE if failed // read register and modify entry->reg; return FALSE if failed
int read_entry(dicentry_t *entry){ bool read_entry(dicentry_t *entry){
if(!modbus_ctx) return FALSE; if(!modbus_ctx) return false;
if(!entry){ if(!entry){
WARNX("NULL instead of entry"); WARNX("NULL instead of entry");
return FALSE; return false;
} }
int ret = TRUE; bool ret = true;
pthread_mutex_lock(&modbus_mutex); pthread_mutex_lock(&modbus_mutex);
if(modbus_read_registers(modbus_ctx, entry->reg, 1, &entry->value) < 0 && int rc = modbus_read_registers(modbus_ctx, entry->reg, 1, &entry->value);
modbus_read_input_registers(modbus_ctx, entry->reg, 1, &entry->value) < 0){ if(rc < 0){
modbus_flush(modbus_ctx);
rc = modbus_read_input_registers(modbus_ctx, entry->reg, 1, &entry->value);
}
if(rc < 0){
WARNX("Can't read entry by reg %u", entry->reg); WARNX("Can't read entry by reg %u", entry->reg);
ret = FALSE; ret = false;
} }
pthread_mutex_unlock(&modbus_mutex); pthread_mutex_unlock(&modbus_mutex);
return ret; return ret;
} }
// write register value; FALSE - if failed or read-only // write register value; FALSE - if failed or read-only
int write_entry(dicentry_t *entry){ bool write_entry(dicentry_t *entry){
if(!modbus_ctx) return FALSE; if(!modbus_ctx) return false;
if(!entry || entry->readonly){ if(!entry || entry->readonly){
if(!entry) WARNX("NULL instead of entry"); if(!entry) WARNX("NULL instead of entry");
else WARNX("Can't write readonly entry %u", entry->reg); else WARNX("Can't write readonly entry %u", entry->reg);
return FALSE; return false;
} }
int ret = TRUE; bool ret = true;
pthread_mutex_lock(&modbus_mutex); pthread_mutex_lock(&modbus_mutex);
if(modbus_write_register(modbus_ctx, entry->reg, entry->value) < 0){ if(modbus_write_register(modbus_ctx, entry->reg, entry->value) < 0){
WARNX("Error writing %u to %u", entry->value, entry->reg); WARNX("Error writing %u to %u", entry->value, entry->reg);
ret = FALSE; ret = false;
} }
pthread_mutex_unlock(&modbus_mutex); pthread_mutex_unlock(&modbus_mutex);
return ret; return ret;
@@ -108,7 +116,7 @@ int write_regval(char **regval){
// write multiply regs by NULL-terminated array "keycode=val" (checking `keycode`); return amount of items written // write multiply regs by NULL-terminated array "keycode=val" (checking `keycode`); return amount of items written
int write_codeval(char **codeval){ int write_codeval(char **codeval){
if(!chkdict()) return FALSE; if(!chkdict()) return 0;
int written = 0; int written = 0;
dicentry_t entry = {0}; dicentry_t entry = {0};
while(*codeval){ while(*codeval){
@@ -143,11 +151,17 @@ int write_codeval(char **codeval){
return written; return written;
} }
int open_modbus(const char *path, int baudrate){ bool open_modbus(const char *path, const char *format, int baudrate){
int ret = FALSE; if(!path || !format) return false;
bool ret = false;
if(strlen(format) != 3) return false; // linux doesn't support 1.5 stop bits
char parity = format[1];
int databits = format[0] - '0', stopbits = format[2] - '0';
DBG("Try to open modbus @%s with speed %d, parity: %c, %d data bits and %d stop bits",
path, baudrate, parity, databits, stopbits);
if(modbus_ctx) close_modbus(); if(modbus_ctx) close_modbus();
pthread_mutex_lock(&modbus_mutex); pthread_mutex_lock(&modbus_mutex);
modbus_ctx = modbus_new_rtu(path, baudrate, 'N', 8, 1); modbus_ctx = modbus_new_rtu(path, baudrate, parity, databits, stopbits);
if(!modbus_ctx){ if(!modbus_ctx){
WARNX("Can't open device %s @ %d", path, baudrate); WARNX("Can't open device %s @ %d", path, baudrate);
goto rtn; goto rtn;
@@ -159,24 +173,30 @@ int open_modbus(const char *path, int baudrate){
modbus_ctx = NULL; modbus_ctx = NULL;
goto rtn; goto rtn;
} }
ret = TRUE; ret = true;
rtn: rtn:
pthread_mutex_unlock(&modbus_mutex); pthread_mutex_unlock(&modbus_mutex);
return ret; return ret;
} }
int set_slave(int ID){ bool set_slave(int ID){
int ret = TRUE; bool ret = true;
if(!modbus_ctx) return FALSE; if(!modbus_ctx) return false;
pthread_mutex_lock(&modbus_mutex); pthread_mutex_lock(&modbus_mutex);
modbus_flush(modbus_ctx); // flush modbus to clear trash
if(modbus_set_slave(modbus_ctx, ID)){ if(modbus_set_slave(modbus_ctx, ID)){
WARNX("Can't set slave ID to %d", ID); WARNX("Can't set slave ID to %d", ID);
ret = FALSE; ret = false;
} }else atomic_store(&slaveID, ID);
pthread_mutex_unlock(&modbus_mutex); pthread_mutex_unlock(&modbus_mutex);
return ret; return ret;
} }
int get_slave(){
int slave = atomic_load(&slaveID);
return slave;
}
// read dump register values (not checking in dict) and dump to stdout (not modifying dictionary) // read dump register values (not checking in dict) and dump to stdout (not modifying dictionary)
void read_registers(int **addresses){ void read_registers(int **addresses){
dicentry_t entry = {0}; dicentry_t entry = {0};
@@ -213,61 +233,61 @@ void read_keycodes(char **keycodes){
printf("\n"); printf("\n");
} }
int read_coils(int nbytes, uint8_t *dest){ bool read_coils(int nbytes, uint8_t *dest){
if(!modbus_ctx || !dest || nbytes < 1 || nbytes > MAX_READ_BITS / 8){ if(!modbus_ctx || !dest || nbytes < 1 || nbytes > MAX_READ_BITS / 8){
WARNX("Bad coils read request"); WARNX("Bad coils read request");
return FALSE; return false;
} }
int ret = TRUE; bool ret = true;
DBG("Try to read %d bits", nbytes * 8); DBG("Try to read %d bits", nbytes * 8);
pthread_mutex_lock(&modbus_mutex); pthread_mutex_lock(&modbus_mutex);
if(modbus_read_bits(modbus_ctx, 0, nbytes * 8, dest) < 0){ if(modbus_read_bits(modbus_ctx, 0, nbytes * 8, dest) < 0){
WARNX("Can't read coils"); WARNX("Can't read coils");
ret = FALSE; ret = false;
} }
pthread_mutex_unlock(&modbus_mutex); pthread_mutex_unlock(&modbus_mutex);
return ret; return ret;
} }
int read_inputs(int nbytes, uint8_t *dest){ bool read_inputs(int nbytes, uint8_t *dest){
if(!modbus_ctx || !dest || nbytes < 1 || nbytes > MAX_READ_BITS / 8){ if(!modbus_ctx || !dest || nbytes < 1 || nbytes > MAX_READ_BITS / 8){
WARNX("Bad inputs read request"); WARNX("Bad inputs read request");
return FALSE; return false;
} }
int ret = TRUE; bool ret = true;
pthread_mutex_lock(&modbus_mutex); pthread_mutex_lock(&modbus_mutex);
if(modbus_read_input_bits(modbus_ctx, 0, nbytes * 8, dest) < 0){ if(modbus_read_input_bits(modbus_ctx, 0, nbytes * 8, dest) < 0){
WARNX("Can't read discrete inputs"); WARNX("Can't read discrete inputs");
ret = FALSE; ret = false;
} }
pthread_mutex_unlock(&modbus_mutex); pthread_mutex_unlock(&modbus_mutex);
return ret; return ret;
} }
int write_coils(int nbytes, const uint8_t *src){ bool write_coils(int nbytes, const uint8_t *src){
if(!modbus_ctx || !src || nbytes < 1 || nbytes > MAX_WRITE_BITS / 8){ if(!modbus_ctx || !src || nbytes < 1 || nbytes > MAX_WRITE_BITS / 8){
WARNX("Bad coils write request"); WARNX("Bad coils write request");
return FALSE; return false;
} }
int ret = TRUE; bool ret = true;
pthread_mutex_lock(&modbus_mutex); pthread_mutex_lock(&modbus_mutex);
if(modbus_write_bits(modbus_ctx, 0, nbytes * 8, src) < 0){ if(modbus_write_bits(modbus_ctx, 0, nbytes * 8, src) < 0){
WARNX("Can't write coils"); WARNX("Can't write coils");
ret = FALSE; ret = false;
} }
pthread_mutex_unlock(&modbus_mutex); pthread_mutex_unlock(&modbus_mutex);
return ret; return ret;
} }
int write_coil(int index, int value){ bool write_coil(int index, int value){
if(!modbus_ctx || index < 0 || index > MAX_WRITE_BITS - 1){ if(!modbus_ctx || index < 0 || index > MAX_WRITE_BITS - 1){
WARNX("Bad coil write request"); WARNX("Bad coil write request");
return FALSE; return false;
} }
int ret = TRUE; bool ret = true;
pthread_mutex_lock(&modbus_mutex); pthread_mutex_lock(&modbus_mutex);
if(modbus_write_bit(modbus_ctx, index, value) < 0){ if(modbus_write_bit(modbus_ctx, index, value) < 0){
ret = FALSE; ret = false;
WARNX("Can't set coil %d to %d", index, value); WARNX("Can't set coil %d to %d", index, value);
} }
pthread_mutex_unlock(&modbus_mutex); pthread_mutex_unlock(&modbus_mutex);

View File

@@ -20,17 +20,18 @@
#include "dictionary.h" #include "dictionary.h"
int open_modbus(const char *path, int baudrate); bool open_modbus(const char *path, const char *format, int baudrate);
void close_modbus(); void close_modbus();
int set_slave(int ID); bool set_slave(int ID);
int get_slave();
int read_coils(int nbytes, uint8_t *dest); bool read_coils(int nbytes, uint8_t *dest);
int read_inputs(int nbytes, uint8_t *dest); bool read_inputs(int nbytes, uint8_t *dest);
int write_coils(int nbytes, const uint8_t *src); bool write_coils(int nbytes, const uint8_t *src);
int write_coil(int index, int value); bool write_coil(int index, int value);
int read_entry(dicentry_t *entry); bool read_entry(dicentry_t *entry);
int write_entry(dicentry_t *entry); bool write_entry(dicentry_t *entry);
int write_regval(char **regval); int write_regval(char **regval);
int write_codeval(char **codeval); int write_codeval(char **codeval);

View File

@@ -1 +1 @@
-std=c17 -std=gnu23

View File

@@ -1 +1 @@
-std=c++17 -std=c++23

View File

@@ -30,6 +30,8 @@ static sl_sock_t *s = NULL;
// amount of input/output bytes // amount of input/output bytes
static int input_bytes = 0; static int input_bytes = 0;
static int coils_bytes = 0; static int coils_bytes = 0;
// if exitjob == 1 we should stop server
static bool exitjob = false;
// specific bit to read/write // specific bit to read/write
static sl_sock_keyno_t rinputs = SL_SOCK_KEYNO_DEFAULT, static sl_sock_keyno_t rinputs = SL_SOCK_KEYNO_DEFAULT,
@@ -42,26 +44,26 @@ void set_io_sizes(int inputs, int coils){
coils_bytes = (coils > 0) ? coils : 0; coils_bytes = (coils > 0) ? coils : 0;
} }
static int bytes_to_num(const uint8_t *buf, int n, uint64_t *out){ static bool bytes_to_num(const uint8_t *buf, int n, uint64_t *out){
if(!buf || !out || n < 1 || n > 64) return FALSE; if(!buf || !out || n < 1 || n > 64) return false;
uint64_t result = 0; uint64_t result = 0;
for(int i = n - 1; i > -1; --i){ for(int i = n - 1; i > -1; --i){
result <<= 1; result <<= 1;
if(buf[i]) result |= 1; if(buf[i]) result |= 1;
} }
*out = result; *out = result;
return TRUE; return true;
} }
static int num_to_bytes(uint64_t in, uint8_t *buf, int n){ static bool num_to_bytes(uint64_t in, uint8_t *buf, int n){
if(!buf || n < 1 || n > 64) return FALSE; if(!buf || n < 1 || n > 64) return false;
uint64_t mask = 1; uint64_t mask = 1;
for(int i = 0; i < n; ++i){ for(int i = 0; i < n; ++i){
if(in & mask) buf[i] = 1; if(in & mask) buf[i] = 1;
else buf[i] = 0; else buf[i] = 0;
mask <<= 1; mask <<= 1;
} }
return TRUE; return true;
} }
// stop dump and close dump file // stop dump and close dump file
@@ -73,7 +75,8 @@ static sl_sock_hresult_e closedump(_U_ sl_sock_t *client, _U_ sl_sock_hitem_t *i
static sl_sock_hresult_e newdump(sl_sock_t *client, _U_ sl_sock_hitem_t *item, const char *req){ static sl_sock_hresult_e newdump(sl_sock_t *client, _U_ sl_sock_hitem_t *item, const char *req){
char buf[BUFSIZ]; char buf[BUFSIZ];
if(!req){ // getter if(!req){ // getter
snprintf(buf, BUFSIZ-1, "%s = %s\n", item->key, getdumpname()); const char *n = getdumpname();
snprintf(buf, BUFSIZ-1, "%s = %s\n", item->key, n ? n : "(none)");
sl_sock_sendstrmessage(client, buf); sl_sock_sendstrmessage(client, buf);
return RESULT_SILENCE; return RESULT_SILENCE;
}else{ }else{
@@ -195,31 +198,47 @@ static sl_sock_hresult_e writecoils(_U_ sl_sock_t *client, _U_ sl_sock_hitem_t *
return RESULT_BADVAL; return RESULT_BADVAL;
} }
bits = (uint64_t) ll; bits = (uint64_t) ll;
int ok = FALSE; bool ok = false;
if(no > -1){ // change state of specific coil if(no > -1){ // change state of specific coil
ok = write_coil(no, bits); ok = write_coil(no, bits);
}else{ }else{
if(!num_to_bytes(bits, buf, coils_bytes*8)){ if(!num_to_bytes(bits, buf, coils_bytes*8)){
WARNX("Bad HEX string for writecoils"); WARNX("Bad parameters for writecoils");
return RESULT_BADVAL; return RESULT_BADVAL;
} }
ok = write_coils(coils_bytes, buf); ok = write_coils(coils_bytes, buf);
} }
if(0 == get_slave()) return RESULT_SILENCE;
return ok ? RESULT_OK : RESULT_FAIL; return ok ? RESULT_OK : RESULT_FAIL;
} }
static sl_sock_hresult_e setid(sl_sock_t *client, _U_ sl_sock_hitem_t *item, const char *req){
char buf[BUFSIZ];
int slaveID;
if(!req){ // getter
slaveID = get_slave();
snprintf(buf, BUFSIZ-1, "%s = %d\n", item->key, slaveID);
sl_sock_sendstrmessage(client, buf);
return RESULT_SILENCE;
}
if(!sl_str2i(&slaveID, req)) return RESULT_BADVAL;
if(!set_slave(slaveID)) return RESULT_FAIL;
return RESULT_OK;
}
static sl_sock_hitem_t handlers[] = { static sl_sock_hitem_t handlers[] = {
{closedump, "clodump", "stop dump and close current dump file", NULL}, {closedump, "clodump", "stop dump and close current dump file", NULL},
{newdump, "newdump", "open new dump file or get name of current", NULL},
{listdict, "list", "list all dictionary (as getter) or given register (as setter: by codename or value)", NULL},
{listaliases, "alias", "list all of aliases (as getter) or with given name (by setter)", NULL}, {listaliases, "alias", "list all of aliases (as getter) or with given name (by setter)", NULL},
{listdict, "list", "list all dictionary (as getter) or given register (as setter: by codename or value)", NULL},
{newdump, "newdump", "open new dump file or get name of current", NULL},
{readcoils, "readcoils", "read all coils as HEX (uses --coils bytes)", (void*)&rcoils}, {readcoils, "readcoils", "read all coils as HEX (uses --coils bytes)", (void*)&rcoils},
{readinputs, "readinputs", "read all discrete inputs as HEX (uses --inputs bytes)", (void*)&rinputs}, {readinputs, "readinputs", "read all discrete inputs as HEX (uses --inputs bytes)", (void*)&rinputs},
{setid, "setid", "set slave's ID", NULL},
{writecoils, "writecoils", "write all coils from HEX number (uses --coils bytes)", (void*)&wcoils}, {writecoils, "writecoils", "write all coils from HEX number (uses --coils bytes)", (void*)&wcoils},
{NULL, NULL, NULL, NULL} {NULL, NULL, NULL, NULL}
}; };
// new connections handler (return FALSE to reject client) // new connections handler (return FALSE to reject client); should be INT!
static int connected(sl_sock_t *c){ static int connected(sl_sock_t *c){
if(c->type == SOCKT_UNIX) LOGMSG("New client fd=%d connected", c->fd); if(c->type == SOCKT_UNIX) LOGMSG("New client fd=%d connected", c->fd);
else LOGMSG("New client fd=%d, IP=%s connected", c->fd, c->IP); else LOGMSG("New client fd=%d, IP=%s connected", c->fd, c->IP);
@@ -243,6 +262,7 @@ static sl_sock_hresult_e defhandler(sl_sock_t *s, const char *str){
int n = sl_get_keyval(str, key, value); int n = sl_get_keyval(str, key, value);
if(n == 0){ if(n == 0){
WARNX("Can't parse `%s` as reg[=val]", str); WARNX("Can't parse `%s` as reg[=val]", str);
deepcounter = 0;
return RESULT_BADKEY; return RESULT_BADKEY;
} }
dicentry_t *entry = NULL; dicentry_t *entry = NULL;
@@ -262,41 +282,52 @@ static sl_sock_hresult_e defhandler(sl_sock_t *s, const char *str){
} }
} }
WARNX("Entry %s not found", key); WARNX("Entry %s not found", key);
deepcounter = 0;
return RESULT_BADKEY; return RESULT_BADKEY;
} }
deepcounter = 0; deepcounter = 0;
if(n == 1){ // getter if(n == 1){ // getter
if(!read_entry(entry)) return RESULT_FAIL; if(!read_entry(entry)){
return RESULT_FAIL;
}
snprintf(value, SL_VAL_LEN-1, "%s=%u\n", key, entry->value); snprintf(value, SL_VAL_LEN-1, "%s=%u\n", key, entry->value);
}else{ // setterrunserver }else{ // setter
if(!sl_str2i(&N, value)){ if(!sl_str2i(&N, value) || N < 0 || N > 0xffff){
WARNX("%s isn't a value of register", value); WARNX("%s isn't a value of register", value);
return RESULT_BADVAL; return RESULT_BADVAL;
} }
entry->value = (uint16_t)N; if(entry->readonly){
WARNX("%s is readonly register", entry->code);
return RESULT_FAIL;
}
if(0 == get_slave()){ // we can't read anything by broadcast address
write_entry(entry);
return RESULT_SILENCE;
}
if(!write_entry(entry)) return RESULT_FAIL; if(!write_entry(entry)) return RESULT_FAIL;
entry->value = (uint16_t)N;
return RESULT_OK; return RESULT_OK;
} }
sl_sock_sendstrmessage(s, value); sl_sock_sendstrmessage(s, value);
return RESULT_SILENCE; return RESULT_SILENCE;
} }
int runserver(const char *node, int isunix){ bool runserver(const char *node, int isunix){
if(!node){ if(!node){
WARNX("Point node"); WARNX("Point node");
return FALSE; return false;
} }
sl_socktype_e type = (isunix) ? SOCKT_UNIX : SOCKT_NET; sl_socktype_e type = (isunix) ? SOCKT_UNIX : SOCKT_NET;
if(s) sl_sock_delete(&s); if(s) sl_sock_delete(&s);
s = sl_sock_run_server(type, node, -1, handlers); s = sl_sock_run_server(type, node, -1, handlers);
if(!s){ if(!s){
WARNX("Can't run server"); WARNX("Can't run server");
return FALSE; return false;
} }
sl_sock_connhandler(s, connected); sl_sock_connhandler(s, connected);
sl_sock_dischandler(s, disconnected); sl_sock_dischandler(s, disconnected);
sl_sock_defmsghandler(s, defhandler); sl_sock_defmsghandler(s, defhandler);
while(s && s->connected){ while(!exitjob && s && s->connected ){
if(!s->rthread){ if(!s->rthread){
WARNX("Server handlers thread is dead"); WARNX("Server handlers thread is dead");
break; break;
@@ -305,5 +336,7 @@ int runserver(const char *node, int isunix){
} }
DBG("Close"); DBG("Close");
sl_sock_delete(&s); sl_sock_delete(&s);
return TRUE; return true;
} }
void stop_server(){exitjob = true; }

View File

@@ -20,5 +20,6 @@
#include <usefull_macros.h> #include <usefull_macros.h>
int runserver(const char *node, int isunix); bool runserver(const char *node, int isunix);
void set_io_sizes(int inputs, int coils); void set_io_sizes(int inputs, int coils);
void stop_server();

View File

@@ -23,10 +23,12 @@
static sl_loglevel_e verblvl = LOGLEVEL_WARN; static sl_loglevel_e verblvl = LOGLEVEL_WARN;
void set_verbose_level(sl_loglevel_e level){ void set_verbose_level(sl_loglevel_e *level){
if(level >= LOGLEVEL_AMOUNT) level = LOGLEVEL_AMOUNT - 1; if(!level) return;
else if(level < 0) level = 0; sl_loglevel_e l = *level;
verblvl = level; if(l >= LOGLEVEL_AMOUNT) l = LOGLEVEL_AMOUNT - 1;
else if(l < 0) l = 0;
verblvl = *level = l;
} }
void verbose(sl_loglevel_e lvl, const char *fmt, ...){ void verbose(sl_loglevel_e lvl, const char *fmt, ...){

View File

@@ -20,5 +20,5 @@
#include <usefull_macros.h> #include <usefull_macros.h>
void set_verbose_level(sl_loglevel_e level); void set_verbose_level(sl_loglevel_e *level);
void verbose(sl_loglevel_e lvl, const char *fmt, ...); void verbose(sl_loglevel_e lvl, const char *fmt, ...);