js331zc/BachelorThesis
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
9b53609df1
BachelorThesis/server.c
Jozef Šimko 9b53609df1 update date
2022-06-07 17:34:20 +00:00

607 lines
16 KiB
C
Raw Blame History

/*
Author: Jozef Simko
School year: 3., Bachelor study, 2021/22
Study program: Computer Networks
Organization: Technical University of Kosice (TUKE), Faculty of Electrical Engineering and Informatics (FEI),
Compiler: Winlibs GCC -- MinGW-W64 x86_64-posix-seh version 11.2.0, built by Brecht Sanders (OS Win)
-- gcc version 9.3.0 (OS Linux)
compile: WIN -- gcc server.c RS232.c -Wall -Wextra -lwsock32 -o server
LINUX -- gcc server.c RS232.c -Wall -Wextra -o server
version: 1.4 , 7.6.2022
Usage: Program communicates with both second program (client) using sockets and lasermeter using RS232 COM port communication.
It works in active or passive mode according input parameters.
*/
#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#include <winsock2.h>
#else
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "rs232.h"
/* Defines lenght of various buffers:
- buffer for message from client
- buffer for reading lines from config file
- buffer for output line which is send to client
Should not be less then 30 */
#define MESSAGE_SIZE 32
/* Pre-defined COM port number from RS-232 library documentation table according to used OS
Documentation - https://www.teuniz.net/RS-232/ */
#define COM_PORT 16
/* COM port baudrate number from RS-232 library - https://www.teuniz.net/RS-232/ */
#define COM_BAUD 115200
/* Pre-defined COM port mode from RS-232 library - https://www.teuniz.net/RS-232/
first number represents databits, letter defines parity and last number is for stopbits */
#define COM_MODE "8N1"
/* Defines lenght of buffer for data from lasermeter
It's better to use higher values, it's helpful in case of hardware/RS-232 overload */
#define COM_BUFFER 4096
/* Amount of seconds used to wait before checking and reading data from RS-232 line
Waiting time should be approx. 0,1 seconds (from RS-232 library), but the lowest
measure (response) time od distance sensor is 0,3 seconds, the greatest value is 4-5 seconds.
Value 1 equals 1 second, which is used in loop checking max response time.
This value fit perfectly for this software and should not be changed.
*/
#define WAIT_TIME 1
/* Definition of struct used in main() */
struct var {
char *name;
int value;
};
/*###########################################
DEFINED FUNCTIONS
#############################################*/
/*
Waits exact number of seconds (with dependency on used OS)
*/
void wait(int sec){
#ifdef _WIN32
Sleep(sec*1000);
#else
sleep(sec);
#endif
return;
}
/*
Returns lasermeter device ID from return value of command "dg"
*/
char getID(int cport_nr){
char dg[] = "dg\r\n";
RS232_cputs(cport_nr, dg);
wait(WAIT_TIME);
unsigned char buf[MESSAGE_SIZE];
if(RS232_PollComport(cport_nr, buf, MESSAGE_SIZE) <= 0){
return 'x';
}
return buf[1];
}
/*
Loads variables from config.txt file to defined struction
Returns pointer on arrays of chars which contain commands from config variables cmd=
*/
char** setVars(struct var *vars, FILE *cfg){
char line[MESSAGE_SIZE];
memset(line, 0, MESSAGE_SIZE);
char **cmds = NULL;
cmds = malloc(sizeof(char *));
int cmdID = 0;
while(fgets(line, sizeof(line), cfg) != NULL) {
if(line[0] == '#' || line[0] == '\n'){
continue;
}
char *second;
char *first = strtok_r(line, "=", &second);
if(strcmp(first, "cmd") == 0){
cmds = realloc(cmds, (cmdID+1)*sizeof(char *));
cmds[cmdID] = malloc(sizeof(char));
second[strcspn(second, "\n")] = 0;
strcpy(cmds[cmdID], second);
cmdID++;
continue;
}
for(int i=0; vars[i].name; i++){
if(strcmp(vars[i].name, first) == 0){
vars[i].value = atoi(second);
}
}
}
cmds = realloc(cmds, (cmdID+1)*sizeof(char *));
cmds[cmdID] = NULL;
return cmds;
}
/*
Frees allocated memory of pointer to arrays of chars
*/
void freeCMDS(char **cmds){
int i=0;
while(cmds[i] != NULL){
free(cmds[i]);
i++;
}
free(cmds);
}
/*
Returns value of variable defined in struction
*/
int getVar(struct var *vars, char *var){
for(int i=0; vars[i].name; i++){
if(strcmp(vars[i].name, var) == 0){
return vars[i].value;
}
}
return -1;
}
/*
Changes "raw" command to usable command for lasermeter
*/
char *makeCMD(char *string, char deviceID){
int n = strlen(string) + 2;
char *ptr = (char *)calloc(n, sizeof(char));
strcpy(ptr, string);
ptr[n-2] = '\r';
ptr[n-1] = '\n';
if(ptr[1] == 'N'){
ptr[1] = deviceID;
}
return ptr;
}
/*
Closes socket (with dependency on used OS)
*/
void cleanUP(int sock){
#ifdef WIN32
closesocket(sock);
WSACleanup();
#else
close(sock);
#endif
return;
}
/* ######################################### */
int main(int argc , char *argv[]){
#ifdef WIN32
WSADATA wsaData;
int iResult = WSAStartup(MAKEWORD(2 ,2), &wsaData);
if (iResult != 0){
printf("WSASturtup() failed\n");
return 0;
}
#endif
int sock;
int client_sock;
int read_size;
struct sockaddr_in server;
struct sockaddr_in client;
char client_message[MESSAGE_SIZE];
memset(client_message, 0, MESSAGE_SIZE);
if (argc < 2 || argc > 3){
fprintf(stderr, "Usage:\n");
fprintf(stderr, "- %s <Server Port>\n", argv[0]);
fprintf(stderr, "- %s <Server Port> <Config file>\n", argv[0]);
return 1;
}
// Decide to use manual or automatic mode
int automatic = 0;
if(argc == 3){
automatic = 1;
}
// Create socket
if ((sock = socket(PF_INET , SOCK_STREAM , IPPROTO_TCP)) < 0){
printf("socket() failed\n");
cleanUP(sock);
return 1;
}
// Prepare the sockaddr_in structure
memset(&server, 0, sizeof(server));
server.sin_family = AF_INET;
server.sin_addr.s_addr = htonl(INADDR_ANY);
server.sin_port = htons(atoi(argv[1]));
// Bind
if (bind(sock,(struct sockaddr *) &server, sizeof(server)) != 0){
printf("bind() failed\n");
cleanUP(sock);
return 1;
}
// Define basic vars struct
struct var vars[] = {
{"comport", 1},
{"baud", 9600},
{"bits", 8},
{"parity", 0},
{"stopbit", 1},
{"measure rate", 0},
{"maxErrors", 5},
{"samples", -1},
{"units", 1},
{"sNuH", 0},
{NULL, 0}
};
FILE *cfg;
char **cmds = NULL;
// Open config and change variables in struct vars
if(automatic == 1){
if ((cfg = fopen(argv[2], "r")) == NULL) {
printf("Error! Config file cannot be opened.\n");
cleanUP(sock);
return 1;
}
cmds = setVars(vars, cfg);
fclose(cfg);
}
int cport_nr = COM_PORT;
int bdrate = COM_BAUD;
unsigned char buf[COM_BUFFER];
char mode[] = COM_MODE;
// Load variables from struct vars
if(automatic == 1){
cport_nr = getVar(vars, "comport");
bdrate = getVar(vars, "baud");
mode[0] = getVar(vars, "bits") + '0';
if(getVar(vars, "parity") == 2){mode[1] = 'E';}
mode[2] = getVar(vars, "stopbit") + '0';
}
if(RS232_OpenComport(cport_nr, bdrate, mode, 0)){
printf("Cannot open comport. Server is shutting down.\n");
cleanUP(sock);
return 1;
}
for(;;){
// Listen
if(listen(sock, 1) != 0){
printf("listen() failed\n");
cleanUP(sock);
return 1;
}
puts("Waiting for incoming connections...");
// Accept connection from an incoming client
#ifdef WIN32
int c = sizeof(server);
client_sock = accept(sock, (struct sockaddr *) &client, &c);
#else
socklen_t c = sizeof(server);
client_sock = accept(sock, (struct sockaddr *) &client, &c);
#endif
if (client_sock < 0){
printf("accept() failed");
cleanUP(sock);
return 1;
}
printf("Connection of client %s accepted\n", inet_ntoa(client.sin_addr));
// Send info about mode to client
char init[2] = "0";
if(automatic == 1){
init[0] = '1';
}
send(client_sock, init, strlen(init), 0);
// Laser sensor start sequence
char deviceID = getID(cport_nr);
if(deviceID == 'x'){
printf("COM port opened, lasermeter not connected! Check your device!\n");
cleanUP(sock);
return 1;
}
char mode[]="sNc\r\n";
mode[1] = deviceID;
RS232_cputs(cport_nr, mode);
wait(WAIT_TIME);
RS232_PollComport(cport_nr, buf, COM_BUFFER);
// Automatic mode
if(automatic == 1){
// Load measure rate
char *mode;
int rate = getVar(vars, "measure rate");
int nDigits = 1;
if(rate != 0){
int n = rate;
while(n!=0){
n=n/10;
nDigits++;
}
nDigits -= 1;
}
// User measurement mode
if(getVar(vars, "sNuH") == 1){
// Send commands from config (**cmds)
int cmd = 0;
while(cmds[cmd] != NULL){
char *ptr = makeCMD(cmds[cmd], deviceID);
RS232_cputs(cport_nr, ptr);
cmd++;
free(ptr);
}
freeCMDS(cmds);
mode = malloc((5+nDigits+1) * sizeof(char));
snprintf(mode, 5+nDigits+1, "sNuh+%d", rate);
}
// Basic measurement mode
else{
mode = malloc((4+nDigits+1) * sizeof(char));
snprintf(mode, 4+nDigits+1, "sNh+%d", rate);
}
mode = makeCMD(mode, deviceID);
RS232_cputs(cport_nr, mode);
free(mode);
wait(WAIT_TIME);
// Variables for errors from distance sensor; list of errors, counter of all errors and counter for errors in row
char *errors = malloc(sizeof(char));
int errCount = 0;
int errInRow = 0;
int maxErrors = getVar(vars, "maxErrors");
int samples = getVar(vars, "samples");
// Counter for samples; value is checked if variable 'samples' is greater than -1 (set in config)
int measureSamples = 0;
// Control variable for error linked with client connection, changes to 1 if error is found later in conditions
int e = 0;
while(1){
// If amount of errors in row (not interrupted by correct value) reach the limit
if(errInRow >= maxErrors){
break;
}
// If max samples variable is set in config and all samples reach the limit
if(samples > -1 && samples == measureSamples){
break;
}
// If client connection error occured
if(e == 1){
break;
}
memset(buf, 0, COM_BUFFER);
RS232_PollComport(cport_nr, buf, COM_BUFFER);
time_t rawtime;
struct tm *timeinfo;
time(&rawtime);
timeinfo = localtime(&rawtime);
char *rest = (char *) buf;
char *first = NULL;
printf("%s", buf);
/* EXPERIMENTAL CODE (not tested)
It happens that sometimes server receives measured value splitted in two halfs.
- it looks like g1g+112\r\n61444\r\n
Following code block demonstrates design of code which can solve this problem.
char halfs[14] = {0};
int halfcount = 0;
// has to change loop(X) condition
while ((first = strtok_r(rest, "\n", &rest))){
first[strcspn(token, "\r")] = 0;
int checkLen = (int)strlen(first);
if(checkLen < 12){
if(halfcount == 0){
strcpy(halfs, first);
halfcount++;
}
else{
strcat(halfs, first);
halfcount = 0;
}
}
first = halfs;
...
...
}
*/
// Split and handle data
// Loop(X)
while((first = strtok_r(rest, "\r\n", &rest))){
// Check and handle error
char *err = NULL;
strtok_r(first, "@", &err);
if(strlen(err) > 0){
errCount++;
errInRow++;
errors = (char *) realloc(errors, (errCount)*6*sizeof(char)+1);
strcat(errors, err);
strcat(errors, "\r\n");
if(errInRow >= maxErrors){
char warning[]="Too many errors! Please check your device!\n";
printf("%s", warning);
printf("%s", errors);
send(client_sock, warning, strlen(warning), 0);
break;
}
}
// Handle other values
else{
/* // EXPERIMENTAL (untested) function
// Check if output result doesnt have incorrect lenght (devided to 2 halfs)
first[strcspn(token, "\r")] = 0;
int checkLen = (int)strlen(first);
if(checkLen < 12){
if(halfcount == 0){
strcpy(halfs, first);
halfcount++;
}
else{
strcat(halfs, first);
halfcount = 0;
}
}
first = halfs;
*/
// Change string to integer
int res = 0;
char *numbers = NULL;
strtok_r(first, "+", &numbers);
res = atoi(numbers);
if(res == 0){
continue;
}
int units = getVar(vars, "units");
// Change integer to double and apply set units
double resd = res * (1/(double)units);
char output[MESSAGE_SIZE];
memset(output, 0, MESSAGE_SIZE);
// Add time stamp to result
snprintf(output, MESSAGE_SIZE, "%02d/%02d/%d - %02d:%02d:%02d: %0.2f\n", timeinfo->tm_mday, timeinfo->tm_mon+1, timeinfo->tm_year+1900,
timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec, resd);
errInRow = 0;
measureSamples++;
// Check availability of client
#ifdef WIN32
int iResult = send(client_sock, output, strlen(output), 0);
if(iResult == WSAETIMEDOUT){
printf("Client disconnected!\n");
e = 1;
break;
}
#else
send(client_sock, output, strlen(output), MSG_NOSIGNAL);
if(errno == EPIPE){
printf("Client disconnected!\n");
e = 1;
break;
}
#endif
if(samples > -1 && samples == measureSamples){
break;
}
}
}
}
// Automatic mode end sequence
wait(WAIT_TIME);
char stop[] = "sNc\r\n";
stop[1] = deviceID;
RS232_cputs(cport_nr, stop);
memset(buf, 0, COM_BUFFER);
if(e == 0){
char end[] = "%";
send(client_sock, end, 1, 0);
}
wait(WAIT_TIME);
printf("End of measuring, shutting down server.\n");
break;
}
// Manual mode
else{
// Receive a message from client
while ((read_size = recv(client_sock, client_message, MESSAGE_SIZE, 0)) > 0 ){
memset(buf, 0, COM_BUFFER);
char *ptr = makeCMD(client_message, deviceID);
RS232_cputs(cport_nr, ptr);
int checkCOM = 0;
while(RS232_PollComport(cport_nr, buf, COM_BUFFER) <= 0){
wait(WAIT_TIME);
if(checkCOM == 5){
char info[] = "No response from COM port, check your device and all cables!\n";
send(client_sock, info, strlen(info), 0);
printf("Empty COM-PORT buffer!\n");
cleanUP(sock);
return 1;
}
checkCOM++;
}
// Send received data back to client
send(client_sock, (char*) buf, strlen((char *)buf), 0);
memset(client_message, 0, MESSAGE_SIZE);
free(ptr);
}
if(read_size <= 0){
puts("Client disconnected.\n");
}
}
}
cleanUP(sock);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink