radio95/rds95
0
1
Fork 0
mirror of https://github.com/radio95-rnt/rds95.git synced 2026-07-30 08:49:15 +02:00
Code Issues Wiki Activity

overhaul of some files (i plan to overhaul the rds encoder completly)

Browse Source
This commit is contained in:
kuba
2025-03-12 18:42:55 +01:00
parent eeace56821
commit 3446928850
6 changed files with 472 additions and 343 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.vscode/settings.json
Vendored
+4 -1
View File
@@ -3,6 +3,9 @@
"files.associations": { "files.associations": {
"ascii_cmd.h": "c", "ascii_cmd.h": "c",
"time.h": "c", "time.h": "c",
"rds.h": "c" "rds.h": "c",
"lib.h": "c",
"common.h": "c",
"modulator.h": "c"
} }
} }
src/ascii_cmd.c
+411 -296
View File
@@ -5,301 +5,416 @@
#define CMD_MATCHES(a) (ustrcmp(cmd, (unsigned char *)a) == 0) #define CMD_MATCHES(a) (ustrcmp(cmd, (unsigned char *)a) == 0)
void process_ascii_cmd(unsigned char *str) { typedef struct {
unsigned char *cmd, *arg; const char *cmd;
uint16_t cmd_len = 0; void (*handler)(unsigned char *arg);
uint8_t cmd_length;
} command_handler_t;
cmd_len = _strnlen((const char*)str, CTL_BUFFER_SIZE); // Command handlers
static void handle_cg(unsigned char *arg) {
if (cmd_len > 3 && str[2] == ' ') { uint16_t blocks[4];
cmd = str; int count = sscanf((const char*)arg, "%hX %hX %hX %hX",
cmd[2] = 0; &blocks[0], &blocks[1], &blocks[2], &blocks[3]);
arg = str + 3; if (count == 4) {
set_rds_cg(blocks);
if (CMD_MATCHES("CG")) { }
/* this stays */ }
uint16_t blocks[4];
int count = sscanf((const char*)arg, "%hX %hX %hX %hX", static void handle_text(unsigned char *arg) {
&blocks[0], &blocks[1], arg[RT_LENGTH * 2] = 0;
&blocks[2], &blocks[3]); set_rds_rt1(xlat(arg));
if (count == 4) { }
set_rds_cg(blocks);
} static void handle_ptyn(unsigned char *arg) {
return; arg[PTYN_LENGTH] = 0;
} set_rds_ptyn(xlat(arg));
} }
if(cmd_len == 5) { static void handle_afch(unsigned char *arg) {
cmd = str; if (arg[0] == 'A' || arg[0] == 'B') {
if(CMD_MATCHES("AFCH=")) { return;
clear_rds_af(); }
return;
} clear_rds_af();
} uint8_t arg_count;
if (cmd_len > 5 && str[4] == '=') { rds_af_t new_af;
/* compatibilty with existing (standarts)*/ uint8_t af[MAX_AFS], *af_iter;
cmd = str;
cmd[4] = 0; arg_count = sscanf((char *)arg,
arg = str + 5; "%hhx,%hhx,%hhx,%hhx,%hhx,"
if (CMD_MATCHES("TEXT")) { "%hhx,%hhx,%hhx,%hhx,%hhx,"
arg[RT_LENGTH * 2] = 0; "%hhx,%hhx,%hhx,%hhx,%hhx,"
set_rds_rt1(xlat(arg)); "%hhx,%hhx,%hhx,%hhx,%hhx,"
return; "%hhx,%hhx,%hhx,%hhx,%hhx",
} &af[0], &af[1], &af[2], &af[3], &af[4],
if (CMD_MATCHES("PTYN")) { &af[5], &af[6], &af[7], &af[8], &af[9],
arg[PTYN_LENGTH] = 0; &af[10], &af[11], &af[12], &af[13], &af[14],
set_rds_ptyn(xlat(arg)); &af[15], &af[16], &af[17], &af[18], &af[19],
return; &af[20], &af[21], &af[22], &af[23], &af[24]);
}
if (CMD_MATCHES("AFCH")) { af_iter = af;
if(arg[0] == 'A' || arg[0] == 'B') { memset(&new_af, 0, sizeof(struct rds_af_t));
return;
} while (arg_count-- != 0) {
clear_rds_af(); uint8_t current_value = *af_iter;
uint8_t arg_count; float frequency = (875.0 + current_value) / 10.0;
rds_af_t new_af; add_rds_af(&new_af, frequency);
uint8_t af[MAX_AFS], *af_iter; af_iter++;
arg_count = sscanf((char *)arg, }
"%hhx,%hhx,%hhx,%hhx,%hhx," /* AF list */
"%hhx,%hhx,%hhx,%hhx,%hhx," set_rds_af(new_af);
"%hhx,%hhx,%hhx,%hhx,%hhx," }
"%hhx,%hhx,%hhx,%hhx,%hhx,"
"%hhx,%hhx,%hhx,%hhx,%hhx", static void handle_udg1(unsigned char *arg) {
&af[0], &af[1], &af[2], &af[3], &af[4], // TODO: implement
&af[5], &af[6], &af[7], &af[8], &af[9], }
&af[10], &af[11], &af[12], &af[13], &af[14],
&af[15], &af[16], &af[17], &af[18], &af[19], static void handle_udg2(unsigned char *arg) {
&af[20], &af[21], &af[22], &af[23], &af[24]); // TODO: implement
}
af_iter = af;
memset(&new_af, 0, sizeof(struct rds_af_t)); static void handle_tps(unsigned char *arg) {
while (arg_count-- != 0) { arg[PS_LENGTH * 2] = 0;
uint8_t current_value = *af_iter; set_rds_tps(xlat(arg));
float frequency = (875.0 + current_value) / 10.0; set_rds_tpson(1);
add_rds_af(&new_af, frequency); }
af_iter++;
} static void handle_rt1(unsigned char *arg) {
set_rds_af(new_af); arg[RT_LENGTH * 2] = 0;
return; set_rds_rt1(xlat(arg));
} }
}
static void handle_pty(unsigned char *arg) {
if(cmd_len == 4) { arg[2] = 0;
cmd = str; set_rds_pty(strtoul((char *)arg, NULL, 10));
if(CMD_MATCHES("TPS=")) { }
set_rds_tpson(0);
return; static void handle_ecc(unsigned char *arg) {
} arg[2] = 0;
if(CMD_MATCHES("LPS=")) { set_rds_ecc(strtoul((char *)arg, NULL, 16));
set_rds_lpson(0); }
return;
} static void handle_lic(unsigned char *arg) {
} arg[2] = 0;
if (cmd_len > 4 && str[3] == '=') { set_rds_lic(strtoul((char *)arg, NULL, 16));
cmd = str; }
cmd[3] = 0;
arg = str + 4; #ifdef ODA_RTP
if (CMD_MATCHES("TPS")) { static void handle_rtp(unsigned char *arg) {
arg[PS_LENGTH * 2] = 0; char tag_names[2][32];
set_rds_tps(xlat(arg)); uint8_t tags[6];
set_rds_tpson(1);
return; if (sscanf((char *)arg, "%hhu,%hhu,%hhu,%hhu,%hhu,%hhu",
} &tags[0], &tags[1], &tags[2], &tags[3], &tags[4], &tags[5]) == 6) {
if (CMD_MATCHES("RT1")) { set_rds_rtplus_tags(tags);
arg[RT_LENGTH * 2] = 0; } else if (sscanf((char *)arg, "%31[^,],%hhu,%hhu,%31[^,],%hhu,%hhu",
set_rds_rt1(xlat(arg)); tag_names[0], &tags[1], &tags[2], tag_names[1], &tags[4], &tags[5]) == 6) {
return; tags[0] = get_rtp_tag_id(tag_names[0]);
} tags[3] = get_rtp_tag_id(tag_names[1]);
if (CMD_MATCHES("PTY")) { set_rds_rtplus_tags(tags);
arg[2] = 0; }
set_rds_pty(strtoul((char *)arg, NULL, 10)); }
return; #endif
}
if (CMD_MATCHES("ECC")) { static void handle_lps(unsigned char *arg) {
arg[2] = 0; arg[LPS_LENGTH] = 0;
set_rds_ecc(strtoul((char *)arg, NULL, 16)); set_rds_lpson(1);
return; set_rds_lps(arg);
} }
if (CMD_MATCHES("LIC")) {
arg[2] = 0; static void handle_pin(unsigned char *arg) {
set_rds_lic(strtoul((char *)arg, NULL, 16)); uint8_t pin[3];
return; if (sscanf((char *)arg, "%hhu,%hhu,%hhu", &pin[0], &pin[1], &pin[2]) == 3) {
} set_rds_pin(pin[0], pin[1], pin[2]);
}
#ifdef ODA_RTP }
if (CMD_MATCHES("RTP")) {
char tag_names[2][32]; static void handle_ps(unsigned char *arg) {
uint8_t tags[6]; if (arg[0] == '\0') arg[0] = ' '; // Fix for strings that start with a space
if (sscanf((char *)arg, "%hhu,%hhu,%hhu,%hhu,%hhu,%hhu", arg[PS_LENGTH * 2] = 0;
&tags[0], &tags[1], &tags[2], &tags[3], set_rds_ps(xlat(arg));
&tags[4], &tags[5]) == 6) { }
set_rds_rtplus_tags(tags);
} else if (sscanf((char *)arg, "%31[^,],%hhu,%hhu,%31[^,],%hhu,%hhu", static void handle_ct(unsigned char *arg) {
tag_names[0], &tags[1], &tags[2], set_rds_ct(arg[0]);
tag_names[1], &tags[4], &tags[5]) == 6) { }
tags[0] = get_rtp_tag_id(tag_names[0]);
tags[3] = get_rtp_tag_id(tag_names[1]); static void handle_di(unsigned char *arg) {
set_rds_rtplus_tags(tags); arg[2] = 0;
} set_rds_di(strtoul((char *)arg, NULL, 10));
return; }
}
#endif static void handle_tp(unsigned char *arg) {
set_rds_tp(arg[0]);
if (CMD_MATCHES("LPS")) { }
arg[LPS_LENGTH] = 0;
set_rds_lpson(1); static void handle_ta(unsigned char *arg) {
set_rds_lps(arg); set_rds_ta(arg[0]);
return; }
}
static void handle_ms(unsigned char *arg) {
if (CMD_MATCHES("PIN")) { set_rds_ms(arg[0]);
uint8_t pin[3]; }
if (sscanf((char *)arg, "%hhu,%hhu,%hhu",
&pin[0], &pin[1], &pin[2]) == 3) { static void handle_pi(unsigned char *arg) {
set_rds_pin(pin[0], pin[1], pin[2]); arg[4] = 0;
} set_rds_pi(strtoul((char *)arg, NULL, 16));
return; }
}
} static void handle_af(unsigned char *arg) {
if(cmd_len == 3) { if (arg[0] == 'A' || arg[0] == 'B') {
cmd = str; return;
if(CMD_MATCHES("AF=")) { }
clear_rds_af();
return; clear_rds_af();
} uint8_t arg_count;
} rds_af_t new_af;
if (cmd_len > 3 && str[2] == '=') { float af[MAX_AFS], *af_iter;
cmd = str;
cmd[2] = 0; arg_count = sscanf((char *)arg,
arg = str + 3; "%f,%f,%f,%f,%f,"
"%f,%f,%f,%f,%f,"
if (CMD_MATCHES("PS")) { "%f,%f,%f,%f,%f,"
if(arg[0] == '\0') arg[0] = ' '; /* fix for strings that start with a space idk why but tps works fine with space started strings */ "%f,%f,%f,%f,%f,"
arg[PS_LENGTH * 2] = 0; "%f,%f,%f,%f,%f",
set_rds_ps(xlat(arg)); &af[0], &af[1], &af[2], &af[3], &af[4],
return; &af[5], &af[6], &af[7], &af[8], &af[9],
} &af[10], &af[11], &af[12], &af[13], &af[14],
if (CMD_MATCHES("CT")) { &af[15], &af[16], &af[17], &af[18], &af[19],
set_rds_ct(arg[0]); &af[20], &af[21], &af[22], &af[23], &af[24]);
return;
} af_iter = af;
if (CMD_MATCHES("DI")) { memset(&new_af, 0, sizeof(struct rds_af_t));
arg[2] = 0;
set_rds_di(strtoul((char *)arg, NULL, 10)); while (arg_count-- != 0) {
return; add_rds_af(&new_af, *af_iter++);
} }
if (CMD_MATCHES("TP")) {
set_rds_tp(arg[0]); set_rds_af(new_af);
return; }
}
if (CMD_MATCHES("TA")) { static void handle_g(unsigned char *arg) {
set_rds_ta(arg[0]); uint16_t blocks[4];
return; blocks[0] = get_rds_pi();
} int count = sscanf((char *)arg, "%4hx%4hx%4hx", &blocks[1], &blocks[2], &blocks[3]);
if (CMD_MATCHES("MS")) { if (count == 3) {
set_rds_ms(arg[0]); set_rds_cg(blocks);
return; }
} }
if (CMD_MATCHES("PI")) {
arg[4] = 0; static void handle_pinen(unsigned char *arg) {
set_rds_pi(strtoul((char *)arg, NULL, 16)); arg[1] = 0;
return; set_rds_pin_enabled(strtoul((char *)arg, NULL, 10));
} }
if (CMD_MATCHES("AF")) { static void handle_rt1en(unsigned char *arg) {
if(arg[0] == 'A' || arg[0] == 'B') { set_rds_rt1_enabled(arg[0]);
return; }
}
clear_rds_af(); static void handle_ptynen(unsigned char *arg) {
uint8_t arg_count; arg[1] = 0;
rds_af_t new_af; set_rds_ptyn_enabled(strtoul((char *)arg, NULL, 10));
float af[MAX_AFS], *af_iter; }
arg_count = sscanf((char *)arg,
"%f,%f,%f,%f,%f," /* AF list */ #ifdef ODA_RTP
"%f,%f,%f,%f,%f," static void handle_rtprun(unsigned char *arg) {
"%f,%f,%f,%f,%f," arg[1] = 0;
"%f,%f,%f,%f,%f," set_rds_rtplus_flags(strtoul((char *)arg, NULL, 10));
"%f,%f,%f,%f,%f", }
&af[0], &af[1], &af[2], &af[3], &af[4], #endif
&af[5], &af[6], &af[7], &af[8], &af[9],
&af[10], &af[11], &af[12], &af[13], &af[14], static void handle_eccen(unsigned char *arg) {
&af[15], &af[16], &af[17], &af[18], &af[19], set_rds_ecclic_toggle(arg[0]);
&af[20], &af[21], &af[22], &af[23], &af[24]); }
af_iter = af;
memset(&new_af, 0, sizeof(struct rds_af_t)); static void handle_clear_af(unsigned char *arg) {
while (arg_count-- != 0) { clear_rds_af();
add_rds_af(&new_af, *af_iter++); }
}
set_rds_af(new_af); static void handle_tps_off(unsigned char *arg) {
return; set_rds_tpson(0);
} }
}
static void handle_lps_off(unsigned char *arg) {
if (cmd_len > 2 && str[1] == '=') { set_rds_lpson(0);
cmd = str; }
cmd[1] = 0;
arg = str + 2; // Command tables organized by delimiter position and command length
if (CMD_MATCHES("G")) { static const command_handler_t commands_space[] = {
uint16_t blocks[4]; {"CG", handle_cg, 2}
if(cmd_len == 14) { };
/* RDS1 Group*/
blocks[0] = get_rds_pi(); static const command_handler_t commands_eq3[] = {
int count = sscanf((char *)arg, "%4hx%4hx%4hx", &blocks[1], &blocks[2], &blocks[3]); {"PS", handle_ps, 2},
if(count == 3) { {"CT", handle_ct, 2},
set_rds_cg(blocks); {"DI", handle_di, 2},
} {"TP", handle_tp, 2},
} {"TA", handle_ta, 2},
return; {"MS", handle_ms, 2},
} {"PI", handle_pi, 2},
} {"AF", handle_af, 2}
if (cmd_len > 6 && str[5] == '=') { };
cmd = str;
cmd[5] = 0; static const command_handler_t commands_eq4[] = {
arg = str + 6; {"TPS", handle_tps, 3},
{"RT1", handle_rt1, 3},
if (CMD_MATCHES("PINEN")) { {"PTY", handle_pty, 3},
arg[1] = 0; {"ECC", handle_ecc, 3},
set_rds_pin_enabled(strtoul((char *)arg, NULL, 10)); {"LIC", handle_lic, 3},
return; #ifdef ODA_RTP
} {"RTP", handle_rtp, 3},
#endif
if (CMD_MATCHES("RT1EN")) { {"LPS", handle_lps, 3},
set_rds_rt1_enabled(arg[0]); {"PIN", handle_pin, 3}
return; };
}
} static const command_handler_t commands_eq5[] = {
{"TEXT", handle_text, 4},
if (cmd_len > 6 && str[5] == '=') { {"PTYN", handle_ptyn, 4},
cmd = str; {"AFCH", handle_afch, 4},
cmd[5] = 0; {"UDG1", handle_udg1, 4}
arg = str + 6; {"UDG2", handle_udg2, 4}
} };
if (cmd_len > 7 && str[6] == '=') {
cmd = str; static const command_handler_t commands_eq2[] = {
cmd[6] = 0; {"G", handle_g, 1}
arg = str + 7; };
if (CMD_MATCHES("PTYNEN")) { static const command_handler_t commands_eq6[] = {
arg[1] = 0; {"PINEN", handle_pinen, 5},
set_rds_ptyn_enabled(strtoul((char *)arg, NULL, 10)); {"RT1EN", handle_rt1en, 5},
return; {"ECCEN", handle_eccen, 5}
} };
#ifdef ODA_RTP static const command_handler_t commands_eq7[] = {
if (CMD_MATCHES("RTPRUN")) { {"PTYNEN", handle_ptynen, 6},
arg[1] = 0; #ifdef ODA_RTP
set_rds_rtplus_flags(strtoul((char *)arg, NULL, 10)); {"RTPRUN", handle_rtprun, 6}
return; #endif
} };
#endif
} static const command_handler_t commands_exact[] = {
if (cmd_len > 6 && str[5] == '=') { {"AF=", handle_clear_af, 3},
cmd = str; {"TPS=", handle_tps_off, 4},
cmd[5] = 0; {"LPS=", handle_lps_off, 4},
arg = str + 6; {"AFCH=", handle_clear_af, 5}
if (CMD_MATCHES("ECCEN")) { };
set_rds_ecclic_toggle(arg[0]);
return; // Process a command using the appropriate command table
} static bool process_command_table(const command_handler_t *table, int table_size,
} unsigned char *cmd, unsigned char *arg) {
for (int i = 0; i < table_size; i++) {
if (ustrcmp(cmd, (unsigned char *)table[i].cmd) == 0) {
table[i].handler(arg);
return true;
}
}
return false;
}
void process_ascii_cmd(unsigned char *str) {
unsigned char *cmd, *arg;
uint16_t cmd_len = _strnlen((const char*)str, CTL_BUFFER_SIZE);
// Process exact command matches first
for (int i = 0; i < sizeof(commands_exact) / sizeof(command_handler_t); i++) {
const command_handler_t *handler = &commands_exact[i];
if (cmd_len == handler->cmd_length &&
ustrcmp(str, (unsigned char *)handler->cmd) == 0) {
handler->handler(NULL);
return;
}
}
// Process commands with space delimiter (format: XX y...)
if (cmd_len > 3 && str[2] == ' ') {
cmd = str;
cmd[2] = 0;
arg = str + 3;
if (process_command_table(commands_space,
sizeof(commands_space) / sizeof(command_handler_t),
cmd, arg)) {
return;
}
}
// Process commands with = delimiter at position 2 (format: X=y...)
if (cmd_len > 2 && str[1] == '=') {
cmd = str;
cmd[1] = 0;
arg = str + 2;
if (process_command_table(commands_eq2,
sizeof(commands_eq2) / sizeof(command_handler_t),
cmd, arg)) {
return;
}
}
// Process commands with = delimiter at position 3 (format: XX=y...)
if (cmd_len > 3 && str[2] == '=') {
cmd = str;
cmd[2] = 0;
arg = str + 3;
if (process_command_table(commands_eq3,
sizeof(commands_eq3) / sizeof(command_handler_t),
cmd, arg)) {
return;
}
}
// Process commands with = delimiter at position 4 (format: XXX=y...)
if (cmd_len > 4 && str[3] == '=') {
cmd = str;
cmd[3] = 0;
arg = str + 4;
if (process_command_table(commands_eq4,
sizeof(commands_eq4) / sizeof(command_handler_t),
cmd, arg)) {
return;
}
}
// Process commands with = delimiter at position 5 (format: XXXX=y...)
if (cmd_len > 5 && str[4] == '=') {
cmd = str;
cmd[4] = 0;
arg = str + 5;
if (process_command_table(commands_eq5,
sizeof(commands_eq5) / sizeof(command_handler_t),
cmd, arg)) {
return;
}
}
// Process commands with = delimiter at position 6 (format: XXXXX=y...)
if (cmd_len > 6 && str[5] == '=') {
cmd = str;
cmd[5] = 0;
arg = str + 6;
if (process_command_table(commands_eq6,
sizeof(commands_eq6) / sizeof(command_handler_t),
cmd, arg)) {
return;
}
}
// Process commands with = delimiter at position 7 (format: XXXXXX=y...)
if (cmd_len > 7 && str[6] == '=') {
cmd = str;
cmd[6] = 0;
arg = str + 7;
if (process_command_table(commands_eq7,
sizeof(commands_eq7) / sizeof(command_handler_t),
cmd, arg)) {
return;
}
}
} }
src/control_pipe.c
+49 -37
View File
@@ -2,21 +2,27 @@
#include "ascii_cmd.h" #include "ascii_cmd.h"
#include "control_pipe.h" #include "control_pipe.h"
static int fd; static int fd = -1;
static struct pollfd poller; static struct pollfd poller;
/* /*
* Opens a file (pipe) to be used to control the RDS coder. * Opens a file (pipe) to be used to control the RDS coder.
* Returns 0 on success, -1 on failure.
*/ */
int open_control_pipe(char *filename) { int open_control_pipe(char *filename) {
fd = open(filename, O_RDONLY | O_NONBLOCK); if (!filename) return -1;
if (fd == -1) return -1;
/* setup the poller */ // Close existing pipe if open
poller.fd = fd; if (fd >= 0) close(fd);
poller.events = POLLIN;
return 0; fd = open(filename, O_RDONLY | O_NONBLOCK);
if (fd == -1) return -1;
/* setup the poller */
poller.fd = fd;
poller.events = POLLIN;
return 0;
} }
/* /*
@@ -24,43 +30,49 @@ int open_control_pipe(char *filename) {
* calls process_ascii_cmd. * calls process_ascii_cmd.
*/ */
void poll_control_pipe() { void poll_control_pipe() {
static unsigned char pipe_buf[CTL_BUFFER_SIZE]; static unsigned char pipe_buf[CTL_BUFFER_SIZE];
static unsigned char cmd_buf[CMD_BUFFER_SIZE]; static unsigned char cmd_buf[CMD_BUFFER_SIZE];
struct timeval timeout; char *token, *saveptr;
int ret; int read_bytes;
fd_set set;
char *token;
FD_ZERO(&set); // Return early if file descriptor is invalid
FD_SET(fd, &set); if (fd < 0) return;
timeout.tv_sec = 0;
timeout.tv_usec = READ_TIMEOUT_MS * 1000;
/* check for new commands */ // Check for new commands with a single poll call
if (poll(&poller, 1, READ_TIMEOUT_MS) <= 0) return; if (poll(&poller, 1, READ_TIMEOUT_MS) <= 0) return;
/* return early if there are no new commands */ // Return early if there are no new commands
if (poller.revents == 0) return; if (!(poller.revents & POLLIN)) return;
memset(pipe_buf, 0, CTL_BUFFER_SIZE); // Clear buffer before reading
memset(pipe_buf, 0, CTL_BUFFER_SIZE);
ret = select(fd + 1, &set, NULL, NULL, &timeout); // Read data directly - select is redundant with poll already used above
if (ret == -1 || ret == 0) { read_bytes = read(fd, pipe_buf, CTL_BUFFER_SIZE - 1);
return; if (read_bytes <= 0) return;
} else {
read(fd, pipe_buf, CTL_BUFFER_SIZE - 1);
}
/* handle commands per line this is really good because if were sending text commands very quick after eachother then we can get a rt of for example 'Now its 12:00RT Now its 12:01' */ // Ensure null-termination
token = strtok((char *)pipe_buf, "\n"); pipe_buf[read_bytes] = '\0';
while (token != NULL) {
memset(cmd_buf, 0, CMD_BUFFER_SIZE);
memcpy(cmd_buf, token, CMD_BUFFER_SIZE - 1);
token = strtok(NULL, "\n");
process_ascii_cmd(cmd_buf); /* Process commands line by line */
} token = strtok_r((char *)pipe_buf, "\n", &saveptr);
while (token != NULL) {
size_t cmd_len = strlen(token);
if (cmd_len > 0 && cmd_len < CMD_BUFFER_SIZE) {
memset(cmd_buf, 0, CMD_BUFFER_SIZE);
memcpy(cmd_buf, token, cmd_len);
process_ascii_cmd(cmd_buf);
}
token = strtok_r(NULL, "\n", &saveptr);
}
} }
/*
* Closes the control pipe.
*/
void close_control_pipe() { void close_control_pipe() {
if (fd > 0) close(fd); if (fd >= 0) {
close(fd);
fd = -1;
}
} }
src/lib.c
+3 -4
View File
@@ -12,8 +12,8 @@ void msleep(unsigned long ms) {
} }
/* just like strlen */ /* just like strlen */
size_t _strnlen(const char *s, size_t maxlen) { int _strnlen(const char *s, int maxlen) {
size_t len = 0; int len = 0;
while (s[len] != 0 && len < maxlen) while (s[len] != 0 && len < maxlen)
len++; len++;
return len; return len;
@@ -136,8 +136,7 @@ static uint16_t offset_words[] = {
/* Calculate the checkword for each block and emit the bits */ /* Calculate the checkword for each block and emit the bits */
void add_checkwords(uint16_t *blocks, uint8_t *bits) void add_checkwords(uint16_t *blocks, uint8_t *bits)
{ {
size_t i, j; uint8_t i, j, bit, msb;
uint8_t bit, msb;
uint16_t block, block_crc, check, offset_word; uint16_t block, block_crc, check, offset_word;
bool group_type_b = false; bool group_type_b = false;
if (IS_TYPE_B(blocks)) if (IS_TYPE_B(blocks))
src/lib.h
+1 -1
View File
@@ -1,6 +1,6 @@
extern void msleep(unsigned long ms); extern void msleep(unsigned long ms);
extern size_t _strnlen(const char *s, size_t maxlen); extern int _strnlen(const char *s, int maxlen);
extern int ustrcmp(const unsigned char *s1, const unsigned char *s2); extern int ustrcmp(const unsigned char *s1, const unsigned char *s2);
extern uint8_t get_rtp_tag_id(char *rtp_tag_name); extern uint8_t get_rtp_tag_id(char *rtp_tag_name);
src/rds95.c
+1 -1
View File
@@ -209,7 +209,7 @@ int main(int argc, char **argv) {
static float mpx_buffer[NUM_MPX_FRAMES]; static float mpx_buffer[NUM_MPX_FRAMES];
while(!stop_rds) { while(!stop_rds) {
for (size_t i = 0; i < NUM_MPX_FRAMES; i++) { for (uint16_t i = 0; i < NUM_MPX_FRAMES; i++) {
mpx_buffer[i] = get_rds_sample(); mpx_buffer[i] = get_rds_sample();
} }