mirror of
https://github.com/radio95-rnt/rds95.git
synced 2026-02-27 12:53:53 +01:00
461 lines
13 KiB
C
461 lines
13 KiB
C
#include "common.h"
|
|
#include "rds.h"
|
|
#include "modulator.h"
|
|
#include "lib.h"
|
|
#include "ascii_cmd.h"
|
|
|
|
#define CMD_MATCHES(a) (ustrcmp(cmd, (unsigned char *)a) == 0)
|
|
|
|
typedef struct {
|
|
const char *cmd;
|
|
void (*handler)(unsigned char *arg, RDSModulator* enc);
|
|
uint8_t cmd_length;
|
|
} command_handler_t;
|
|
|
|
// Command handlers
|
|
static void handle_ptyn(unsigned char *arg, RDSModulator* enc) {
|
|
arg[PTYN_LENGTH] = 0;
|
|
set_rds_ptyn(enc->enc, xlat(arg));
|
|
}
|
|
|
|
static void handle_afch(unsigned char *arg, RDSModulator* enc) {
|
|
if (arg[0] == 'A' || arg[0] == 'B') {
|
|
return;
|
|
}
|
|
if(arg[0] == '\0') {
|
|
memset(&(enc->enc->data->af), 0, sizeof(enc->enc->data->af));
|
|
return;
|
|
}
|
|
|
|
memset(&(enc->enc->data->af), 0, sizeof(enc->enc->data->af));
|
|
uint8_t arg_count;
|
|
RDSAFs new_af;
|
|
uint8_t af[MAX_AFS], *af_iter;
|
|
|
|
arg_count = sscanf((char *)arg,
|
|
"%hhx,%hhx,%hhx,%hhx,%hhx,"
|
|
"%hhx,%hhx,%hhx,%hhx,%hhx,"
|
|
"%hhx,%hhx,%hhx,%hhx,%hhx,"
|
|
"%hhx,%hhx,%hhx,%hhx,%hhx,"
|
|
"%hhx,%hhx,%hhx,%hhx,%hhx",
|
|
&af[0], &af[1], &af[2], &af[3], &af[4],
|
|
&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],
|
|
&af[20], &af[21], &af[22], &af[23], &af[24]);
|
|
|
|
af_iter = af;
|
|
memset(&new_af, 0, sizeof(RDSAFs));
|
|
|
|
while (arg_count-- != 0) {
|
|
uint8_t current_value = *af_iter;
|
|
float frequency = (875.0 + current_value) / 10.0;
|
|
add_rds_af(&new_af, frequency);
|
|
af_iter++;
|
|
}
|
|
|
|
memcpy(&(enc->enc->data->af), &new_af, sizeof(enc->enc->data->af));
|
|
}
|
|
|
|
static void handle_tps(unsigned char *arg, RDSModulator* enc) {
|
|
arg[PS_LENGTH * 2] = 0;
|
|
set_rds_tps(enc->enc, xlat(arg));
|
|
}
|
|
|
|
static void handle_rt1(unsigned char *arg, RDSModulator* enc) {
|
|
arg[RT_LENGTH * 2] = 0;
|
|
set_rds_rt1(enc->enc, xlat(arg));
|
|
}
|
|
|
|
static void handle_pty(unsigned char *arg, RDSModulator* enc) {
|
|
arg[2] = 0;
|
|
enc->enc->data->pty = strtoul((char *)arg, NULL, 10);
|
|
}
|
|
|
|
static void handle_ecc(unsigned char *arg, RDSModulator* enc) {
|
|
arg[2] = 0;
|
|
enc->enc->data->ecc = strtoul((char *)arg, NULL, 16);
|
|
}
|
|
|
|
static void handle_lic(unsigned char *arg, RDSModulator* enc) {
|
|
arg[2] = 0;
|
|
enc->enc->data->lic = strtoul((char *)arg, NULL, 16);
|
|
}
|
|
|
|
static void handle_rtp(unsigned char *arg, RDSModulator* enc) {
|
|
char tag_names[2][32];
|
|
uint8_t tags[6];
|
|
|
|
if (sscanf((char *)arg, "%hhu,%hhu,%hhu,%hhu,%hhu,%hhu",
|
|
&tags[0], &tags[1], &tags[2], &tags[3], &tags[4], &tags[5]) == 6) {
|
|
set_rds_rtplus_tags(enc->enc, tags);
|
|
} else if (sscanf((char *)arg, "%31[^,],%hhu,%hhu,%31[^,],%hhu,%hhu",
|
|
tag_names[0], &tags[1], &tags[2], 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]);
|
|
set_rds_rtplus_tags(enc->enc, tags);
|
|
}
|
|
}
|
|
|
|
static void handle_lps(unsigned char *arg, RDSModulator* enc) {
|
|
arg[LPS_LENGTH] = 0;
|
|
set_rds_lps(enc->enc, arg);
|
|
}
|
|
|
|
static void handle_pin(unsigned char *arg, RDSModulator* enc) {
|
|
uint8_t pin[3];
|
|
if (sscanf((char *)arg, "%hhu,%hhu,%hhu", &pin[0], &pin[1], &pin[2]) == 3) {
|
|
for (int i = 0; i < 3; i++) {
|
|
enc->enc->data->pin[i+1] = pin[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
static void handle_ps(unsigned char *arg, RDSModulator* enc) {
|
|
if (arg[0] == '\0') arg[0] = ' '; // Fix for strings that start with a space
|
|
arg[PS_LENGTH * 2] = 0;
|
|
set_rds_ps(enc->enc, xlat(arg));
|
|
}
|
|
|
|
static void handle_ct(unsigned char *arg, RDSModulator* enc) {
|
|
arg[2] = 1;
|
|
enc->enc->data->ct = arg[0];
|
|
}
|
|
|
|
static void handle_di(unsigned char *arg, RDSModulator* enc) {
|
|
arg[2] = 0;
|
|
enc->enc->data->di = arg[0];
|
|
}
|
|
|
|
static void handle_tp(unsigned char *arg, RDSModulator* enc) {
|
|
arg[1] = 0;
|
|
enc->enc->data->tp = arg[0];
|
|
}
|
|
|
|
static void handle_ta(unsigned char *arg, RDSModulator* enc) {
|
|
arg[1] = 0;
|
|
enc->enc->data->ta = arg[0];
|
|
}
|
|
|
|
static void handle_ms(unsigned char *arg, RDSModulator* enc) {
|
|
arg[1] = 0;
|
|
enc->enc->data->ms = arg[0];
|
|
}
|
|
|
|
static void handle_pi(unsigned char *arg, RDSModulator* enc) {
|
|
arg[4] = 0;
|
|
enc->enc->data->pi = strtoul((char *)arg, NULL, 16);
|
|
}
|
|
|
|
static void handle_af(unsigned char *arg, RDSModulator* enc) {
|
|
if (arg[0] == 'A' || arg[0] == 'B') {
|
|
return;
|
|
}
|
|
if(arg[0] == '\0') {
|
|
memset(&(enc->enc->data->af), 0, sizeof(enc->enc->data->af));
|
|
return;
|
|
}
|
|
|
|
memset(&(enc->enc->data->af), 0, sizeof(enc->enc->data->af));
|
|
uint8_t arg_count;
|
|
RDSAFs new_af;
|
|
float af[MAX_AFS], *af_iter;
|
|
|
|
arg_count = sscanf((char *)arg,
|
|
"%f,%f,%f,%f,%f,"
|
|
"%f,%f,%f,%f,%f,"
|
|
"%f,%f,%f,%f,%f,"
|
|
"%f,%f,%f,%f,%f,"
|
|
"%f,%f,%f,%f,%f",
|
|
&af[0], &af[1], &af[2], &af[3], &af[4],
|
|
&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],
|
|
&af[20], &af[21], &af[22], &af[23], &af[24]);
|
|
|
|
af_iter = af;
|
|
memset(&new_af, 0, sizeof(RDSAFs));
|
|
|
|
while (arg_count-- != 0) {
|
|
add_rds_af(&new_af, *af_iter++);
|
|
}
|
|
|
|
memcpy(&(enc->enc->data->af), &new_af, sizeof(enc->enc->data->af));
|
|
}
|
|
|
|
static void handle_g(unsigned char *arg, RDSModulator* enc) {
|
|
uint16_t blocks[3];
|
|
int count = sscanf((char *)arg, "%4hx%4hx%4hx", &blocks[0], &blocks[1], &blocks[2]);
|
|
if (count == 3) {
|
|
enc->enc->state->custom_group[0] = 1;
|
|
enc->enc->state->custom_group[1] = blocks[0];
|
|
enc->enc->state->custom_group[2] = blocks[1];
|
|
enc->enc->state->custom_group[3] = blocks[2];
|
|
}
|
|
}
|
|
|
|
static void handle_pinen(unsigned char *arg, RDSModulator* enc) {
|
|
arg[1] = 0;
|
|
enc->enc->data->pin[0] = arg[0];
|
|
}
|
|
|
|
static void handle_rt1en(unsigned char *arg, RDSModulator* enc) {
|
|
arg[1] = 0;
|
|
enc->enc->data->rt1_enabled = arg[0];
|
|
}
|
|
|
|
static void handle_ptynen(unsigned char *arg, RDSModulator* enc) {
|
|
arg[1] = 0;
|
|
enc->enc->state->ptyn_enabled = strtoul((char *)arg, NULL, 10);
|
|
}
|
|
|
|
static void handle_rtprun(unsigned char *arg, RDSModulator* enc) {
|
|
arg[1] = 0;
|
|
set_rds_rtplus_flags(enc->enc, strtoul((char *)arg, NULL, 10));
|
|
}
|
|
|
|
static void handle_eccen(unsigned char *arg, RDSModulator* enc) {
|
|
arg[1] = 0;
|
|
enc->enc->data->ecclic_enabled = arg[0];
|
|
}
|
|
|
|
static void handle_shortrt(unsigned char *arg, RDSModulator* enc) {
|
|
arg[1] = 0;
|
|
enc->enc->data->shortrt = arg[0];
|
|
}
|
|
|
|
static void handle_grpseq(unsigned char *arg, RDSModulator* enc) {
|
|
memset(&(enc->enc->data->grp_sqc), 0, 24);
|
|
memcpy(&(enc->enc->data->grp_sqc), arg, 24);
|
|
}
|
|
|
|
static void handle_level(unsigned char *arg, RDSModulator* enc) {
|
|
enc->level = strtoul((char *)arg, NULL, 10)/255.0f;
|
|
}
|
|
|
|
static void handle_rdsgen(unsigned char *arg, RDSModulator* enc) {
|
|
enc->rdsgen = strtoul((char *)arg, NULL, 10);
|
|
}
|
|
|
|
static void handle_udg1(unsigned char *arg, RDSModulator* enc) {
|
|
uint16_t blocks[8][3];
|
|
int sets = 0;
|
|
unsigned char *ptr = arg;
|
|
|
|
while (sets < 8) {
|
|
int count = sscanf((char *)ptr, "%4hx%4hx%4hx",
|
|
&blocks[sets][0], &blocks[sets][1], &blocks[sets][2]);
|
|
|
|
if (count != 3) {
|
|
break;
|
|
}
|
|
|
|
sets++;
|
|
|
|
while (*ptr && *ptr != ',') {
|
|
ptr++;
|
|
}
|
|
|
|
if (*ptr == ',') {
|
|
ptr++;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
memcpy(&(enc->enc->data->udg1), &blocks, sets * sizeof(uint16_t[3]));
|
|
enc->enc->data->udg1_len = sets;
|
|
}
|
|
static void handle_udg2(unsigned char *arg, RDSModulator* enc) {
|
|
uint16_t blocks[8][3]; // Up to 8 sets of 3 blocks each
|
|
int sets = 0;
|
|
unsigned char *ptr = arg;
|
|
|
|
while (sets < 8) {
|
|
int count = sscanf((char *)ptr, "%4hx%4hx%4hx",
|
|
&blocks[sets][0], &blocks[sets][1], &blocks[sets][2]);
|
|
|
|
if (count != 3) {
|
|
break; // Couldn't parse a complete set of 3 blocks
|
|
}
|
|
|
|
sets++;
|
|
|
|
// Look for the comma separator
|
|
while (*ptr && *ptr != ',') {
|
|
ptr++;
|
|
}
|
|
|
|
if (*ptr == ',') {
|
|
ptr++; // Skip over the comma
|
|
} else {
|
|
break; // No more separators
|
|
}
|
|
}
|
|
|
|
memcpy(&(enc->enc->data->udg2), &blocks, sets * sizeof(uint16_t[3]));
|
|
enc->enc->data->udg2_len = sets;
|
|
}
|
|
|
|
// Command tables organized by delimiter position and command length
|
|
static const command_handler_t commands_eq3[] = {
|
|
{"PS", handle_ps, 2},
|
|
{"CT", handle_ct, 2},
|
|
{"DI", handle_di, 2},
|
|
{"TP", handle_tp, 2},
|
|
{"TA", handle_ta, 2},
|
|
{"MS", handle_ms, 2},
|
|
{"PI", handle_pi, 2},
|
|
{"AF", handle_af, 2}
|
|
};
|
|
|
|
static const command_handler_t commands_eq4[] = {
|
|
{"TPS", handle_tps, 3},
|
|
{"RT1", handle_rt1, 3},
|
|
{"PTY", handle_pty, 3},
|
|
{"ECC", handle_ecc, 3},
|
|
{"LIC", handle_lic, 3},
|
|
{"RTP", handle_rtp, 3},
|
|
{"LPS", handle_lps, 3},
|
|
{"PIN", handle_pin, 3}
|
|
};
|
|
|
|
static const command_handler_t commands_eq5[] = {
|
|
{"TEXT", handle_rt1, 4},
|
|
{"PTYN", handle_ptyn, 4},
|
|
{"AFCH", handle_afch, 4},
|
|
{"UDG1", handle_udg1, 4},
|
|
{"UDG2", handle_udg2, 4},
|
|
};
|
|
|
|
static const command_handler_t commands_eq2[] = {
|
|
{"G", handle_g, 1}
|
|
};
|
|
|
|
static const command_handler_t commands_eq6[] = {
|
|
{"PINEN", handle_pinen, 5},
|
|
{"RT1EN", handle_rt1en, 5},
|
|
{"ECCEN", handle_eccen, 5},
|
|
{"LEVEL", handle_level, 5}
|
|
};
|
|
|
|
static const command_handler_t commands_eq7[] = {
|
|
{"PTYNEN", handle_ptynen, 6},
|
|
{"RTPRUN", handle_rtprun, 6},
|
|
{"GRPSEQ", handle_grpseq, 6},
|
|
{"RDSGEN", handle_rdsgen, 6}
|
|
};
|
|
|
|
static const command_handler_t commands_eq8[] = {
|
|
{"SHORTRT", handle_shortrt, 7}
|
|
};
|
|
|
|
// 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, RDSModulator* enc) {
|
|
for (int i = 0; i < table_size; i++) {
|
|
if (ustrcmp(cmd, (unsigned char *)table[i].cmd) == 0) {
|
|
table[i].handler(arg, enc);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void process_ascii_cmd(RDSModulator* enc, unsigned char *str) {
|
|
unsigned char *cmd, *arg;
|
|
uint16_t cmd_len = _strnlen((const char*)str, CTL_BUFFER_SIZE);
|
|
|
|
if (str[0] == '*') {
|
|
saveToFile(enc->enc);
|
|
return;
|
|
}
|
|
|
|
if (cmd_len > 1 && 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, enc)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Process commands with = delimiter at position 3 (format: XX=y...)
|
|
if (cmd_len > 2 && 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, enc)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Process commands with = delimiter at position 4 (format: XXX=y...)
|
|
if (cmd_len > 3 && 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, enc)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Process commands with = delimiter at position 5 (format: XXXX=y...)
|
|
if (cmd_len > 4 && 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, enc)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Process commands with = delimiter at position 6 (format: XXXXX=y...)
|
|
if (cmd_len > 5 && 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, enc)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (cmd_len > 6 && 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, enc)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (cmd_len > 7 && str[7] == '=') {
|
|
cmd = str;
|
|
cmd[7] = 0;
|
|
arg = str + 8;
|
|
|
|
if (process_command_table(commands_eq8,
|
|
sizeof(commands_eq8) / sizeof(command_handler_t),
|
|
cmd, arg, enc)) {
|
|
return;
|
|
}
|
|
}
|
|
} |