radio95/rds95
0
1
Fork 0
mirror of https://github.com/radio95-rnt/rds95.git synced 2026-02-27 04:43:52 +01:00
Code Issues Wiki Activity

remove redundant functions, comments, correct function names, optimize the encoder a little bit

Browse Source
This commit is contained in:
KubaPro010
2025-05-30 13:31:15 +02:00
parent 86235ad391
commit 37282a7bf2
6 changed files with 80 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files

123
src/ascii_cmd.c
View File

@@ -15,35 +15,35 @@ typedef struct {
static void handle_ptyn(char *arg, RDSModulator* mod, char* output) { static void handle_ptyn(char *arg, RDSModulator* mod, char* output) {
arg[PTYN_LENGTH*2] = 0; arg[PTYN_LENGTH*2] = 0;
set_rds_ptyn(mod->enc, convert_to_rdscharset(arg)); set_rds_ptyn(mod->enc, convert_to_rdscharset(arg));
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_tps(char *arg, RDSModulator* mod, char* output) { static void handle_tps(char *arg, RDSModulator* mod, char* output) {
arg[PS_LENGTH*2] = 0; arg[PS_LENGTH*2] = 0;
set_rds_tps(mod->enc, convert_to_rdscharset(arg)); set_rds_tps(mod->enc, convert_to_rdscharset(arg));
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_rt1(char *arg, RDSModulator* mod, char* output) { static void handle_rt1(char *arg, RDSModulator* mod, char* output) {
arg[RT_LENGTH*2] = 0; arg[RT_LENGTH*2] = 0;
set_rds_rt1(mod->enc, convert_to_rdscharset(arg)); set_rds_rt1(mod->enc, convert_to_rdscharset(arg));
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_rt2(char *arg, RDSModulator* mod, char* output) { static void handle_rt2(char *arg, RDSModulator* mod, char* output) {
arg[RT_LENGTH*2] = 0; arg[RT_LENGTH*2] = 0;
set_rds_rt2(mod->enc, convert_to_rdscharset(arg)); set_rds_rt2(mod->enc, convert_to_rdscharset(arg));
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_pty(char *arg, RDSModulator* mod, char* output) { static void handle_pty(char *arg, RDSModulator* mod, char* output) {
mod->enc->data[mod->enc->program].pty = atoi(arg); mod->enc->data[mod->enc->program].pty = atoi(arg);
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_ecc(char *arg, RDSModulator* mod, char* output) { static void handle_ecc(char *arg, RDSModulator* mod, char* output) {
mod->enc->data[mod->enc->program].ecc = strtoul(arg, NULL, 16); mod->enc->data[mod->enc->program].ecc = strtoul(arg, NULL, 16);
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_rtp(char *arg, RDSModulator* mod, char* output) { static void handle_rtp(char *arg, RDSModulator* mod, char* output) {
@@ -51,8 +51,8 @@ static void handle_rtp(char *arg, RDSModulator* mod, char* output) {
if (sscanf(arg, "%hhu,%hhu,%hhu,%hhu,%hhu,%hhu", &tags[0], &tags[1], &tags[2], &tags[3], &tags[4], &tags[5]) == 6) { if (sscanf(arg, "%hhu,%hhu,%hhu,%hhu,%hhu,%hhu", &tags[0], &tags[1], &tags[2], &tags[3], &tags[4], &tags[5]) == 6) {
set_rds_rtplus_tags(mod->enc, tags); set_rds_rtplus_tags(mod->enc, tags);
strcpy(output, "+\0"); strcpy(output, "+");
} else strcpy(output, "-\0"); } else strcpy(output, "-");
} }
static void handle_ertp(char *arg, RDSModulator* mod, char* output) { static void handle_ertp(char *arg, RDSModulator* mod, char* output) {
@@ -60,8 +60,8 @@ static void handle_ertp(char *arg, RDSModulator* mod, char* output) {
if (sscanf(arg, "%hhu,%hhu,%hhu,%hhu,%hhu,%hhu", &tags[0], &tags[1], &tags[2], &tags[3], &tags[4], &tags[5]) == 6) { if (sscanf(arg, "%hhu,%hhu,%hhu,%hhu,%hhu,%hhu", &tags[0], &tags[1], &tags[2], &tags[3], &tags[4], &tags[5]) == 6) {
set_rds_ertplus_tags(mod->enc, tags); set_rds_ertplus_tags(mod->enc, tags);
strcpy(output, "+\0"); strcpy(output, "+");
} else strcpy(output, "-\0"); } else strcpy(output, "-");
} }
static void handle_link(char *arg, RDSModulator* mod, char* output) { static void handle_link(char *arg, RDSModulator* mod, char* output) {
@@ -71,60 +71,60 @@ static void handle_link(char *arg, RDSModulator* mod, char* output) {
} }
mod->enc->state[mod->enc->program].eon_linkage = atoi(arg); mod->enc->state[mod->enc->program].eon_linkage = atoi(arg);
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_lps(char *arg, RDSModulator* mod, char* output) { static void handle_lps(char *arg, RDSModulator* mod, char* output) {
arg[LPS_LENGTH*2] = 0; arg[LPS_LENGTH*2] = 0;
set_rds_lps(mod->enc, arg); set_rds_lps(mod->enc, arg);
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_ert(char *arg, RDSModulator* mod, char* output) { static void handle_ert(char *arg, RDSModulator* mod, char* output) {
arg[ERT_LENGTH*2] = 0; arg[ERT_LENGTH*2] = 0;
set_rds_ert(mod->enc, arg); set_rds_ert(mod->enc, arg);
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_ps(char *arg, RDSModulator* mod, char* output) { static void handle_ps(char *arg, RDSModulator* mod, char* output) {
arg[PS_LENGTH*2] = 0; arg[PS_LENGTH*2] = 0;
set_rds_ps(mod->enc, convert_to_rdscharset(arg)); set_rds_ps(mod->enc, convert_to_rdscharset(arg));
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_ct(char *arg, RDSModulator* mod, char* output) { static void handle_ct(char *arg, RDSModulator* mod, char* output) {
mod->enc->data[mod->enc->program].ct = atoi(arg); mod->enc->data[mod->enc->program].ct = atoi(arg);
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_dpty(char *arg, RDSModulator* mod, char* output) { static void handle_dpty(char *arg, RDSModulator* mod, char* output) {
mod->enc->data[mod->enc->program].dpty = atoi(arg); mod->enc->data[mod->enc->program].dpty = atoi(arg);
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_slcd(char *arg, RDSModulator* mod, char* output) { static void handle_slcd(char *arg, RDSModulator* mod, char* output) {
mod->enc->data[mod->enc->program].slc_data = strtoul(arg, NULL, 16); mod->enc->data[mod->enc->program].slc_data = strtoul(arg, NULL, 16);
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_tp(char *arg, RDSModulator* mod, char* output) { static void handle_tp(char *arg, RDSModulator* mod, char* output) {
mod->enc->data[mod->enc->program].tp = atoi(arg); mod->enc->data[mod->enc->program].tp = atoi(arg);
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_ta(char *arg, RDSModulator* mod, char* output) { static void handle_ta(char *arg, RDSModulator* mod, char* output) {
mod->enc->data[mod->enc->program].ta = atoi(arg); mod->enc->data[mod->enc->program].ta = atoi(arg);
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_pi(char *arg, RDSModulator* mod, char* output) { static void handle_pi(char *arg, RDSModulator* mod, char* output) {
uint16_t pi_value = strtoul(arg, NULL, 16); uint16_t pi_value = strtoul(arg, NULL, 16);
if ((pi_value & 0xF000) == 0) { if ((pi_value & 0xF000) == 0) {
strcpy(output, "-\0"); strcpy(output, "-");
return; return;
} }
mod->enc->data[mod->enc->program].pi = pi_value; mod->enc->data[mod->enc->program].pi = pi_value;
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_af(char *arg, RDSModulator* mod, char* output) { static void handle_af(char *arg, RDSModulator* mod, char* output) {
@@ -153,12 +153,10 @@ static void handle_af(char *arg, RDSModulator* mod, char* output) {
af_iter = af; af_iter = af;
memset(&new_af, 0, sizeof(RDSAFs)); memset(&new_af, 0, sizeof(RDSAFs));
while (arg_count-- != 0) { while (arg_count-- != 0) add_rds_af(&new_af, *af_iter++);
add_rds_af(&new_af, *af_iter++);
}
memcpy(&(mod->enc->data[mod->enc->program].af), &new_af, sizeof(mod->enc->data[mod->enc->program].af)); memcpy(&(mod->enc->data[mod->enc->program].af), &new_af, sizeof(mod->enc->data[mod->enc->program].af));
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_afo(char *arg, RDSModulator* mod, char* output) { static void handle_afo(char *arg, RDSModulator* mod, char* output) {
@@ -185,27 +183,24 @@ static void handle_afo(char *arg, RDSModulator* mod, char* output) {
af_iter = af; af_iter = af;
memset(&new_af_oda, 0, sizeof(RDSAFsODA)); memset(&new_af_oda, 0, sizeof(RDSAFsODA));
while (arg_count-- != 0) { while (arg_count-- != 0) add_rds_af_oda(&new_af_oda, *af_iter++);
add_rds_af_oda(&new_af_oda, *af_iter++);
}
memcpy(&(mod->enc->data[mod->enc->program].af_oda), &new_af_oda, sizeof(mod->enc->data[mod->enc->program].af_oda)); memcpy(&(mod->enc->data[mod->enc->program].af_oda), &new_af_oda, sizeof(mod->enc->data[mod->enc->program].af_oda));
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_adr(char *arg, RDSModulator* mod, char* output) { static void handle_adr(char *arg, RDSModulator* mod, char* output) {
uint16_t ids[2]; uint16_t ids[2];
int count = sscanf(arg, "%4hu,%4hu", &ids[0], &ids[1]); int count = sscanf(arg, "%4hu,%4hu", &ids[0], &ids[1]);
if(count == 1) { if(count == 1) mod->enc->encoder_data.encoder_addr[0] = ids[0];
mod->enc->encoder_data.encoder_addr[0] = ids[0]; else if(count == 2) {
} else if(count == 2) {
mod->enc->encoder_data.encoder_addr[0] = ids[0]; mod->enc->encoder_data.encoder_addr[0] = ids[0];
mod->enc->encoder_data.encoder_addr[1] = ids[1]; mod->enc->encoder_data.encoder_addr[1] = ids[1];
} else { } else {
strcpy(output, "-\0"); strcpy(output, "-");
return; return;
} }
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_site(char *arg, RDSModulator* mod, char* output) { static void handle_site(char *arg, RDSModulator* mod, char* output) {
@@ -217,10 +212,10 @@ static void handle_site(char *arg, RDSModulator* mod, char* output) {
mod->enc->encoder_data.site_addr[0] = ids[0]; mod->enc->encoder_data.site_addr[0] = ids[0];
mod->enc->encoder_data.site_addr[1] = ids[1]; mod->enc->encoder_data.site_addr[1] = ids[1];
} else { } else {
strcpy(output, "-\0"); strcpy(output, "-");
return; return;
} }
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_g(char *arg, RDSModulator* mod, char* output) { static void handle_g(char *arg, RDSModulator* mod, char* output) {
@@ -231,56 +226,54 @@ static void handle_g(char *arg, RDSModulator* mod, char* output) {
mod->enc->state[mod->enc->program].custom_group[1] = blocks[0]; mod->enc->state[mod->enc->program].custom_group[1] = blocks[0];
mod->enc->state[mod->enc->program].custom_group[2] = blocks[1]; mod->enc->state[mod->enc->program].custom_group[2] = blocks[1];
mod->enc->state[mod->enc->program].custom_group[3] = blocks[2]; mod->enc->state[mod->enc->program].custom_group[3] = blocks[2];
strcpy(output, "+\0"); strcpy(output, "+");
} else if(count == 4) { } else if(count == 4) {
mod->enc->state[mod->enc->program].custom_group2[0] = 1; mod->enc->state[mod->enc->program].custom_group2[0] = 1;
mod->enc->state[mod->enc->program].custom_group2[1] = blocks[0]; mod->enc->state[mod->enc->program].custom_group2[1] = blocks[0];
mod->enc->state[mod->enc->program].custom_group2[2] = blocks[1]; mod->enc->state[mod->enc->program].custom_group2[2] = blocks[1];
mod->enc->state[mod->enc->program].custom_group2[3] = blocks[2]; mod->enc->state[mod->enc->program].custom_group2[3] = blocks[2];
mod->enc->state[mod->enc->program].custom_group2[4] = blocks[3]; mod->enc->state[mod->enc->program].custom_group2[4] = blocks[3];
strcpy(output, "+\0"); strcpy(output, "+");
} else { } else strcpy(output, "-");
strcpy(output, "-\0");
}
} }
static void handle_rt1en(char *arg, RDSModulator* mod, char* output) { static void handle_rt1en(char *arg, RDSModulator* mod, char* output) {
mod->enc->data[mod->enc->program].rt1_enabled = atoi(arg); mod->enc->data[mod->enc->program].rt1_enabled = atoi(arg);
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_rt2en(char *arg, RDSModulator* mod, char* output) { static void handle_rt2en(char *arg, RDSModulator* mod, char* output) {
mod->enc->data[mod->enc->program].rt2_enabled = atoi(arg); mod->enc->data[mod->enc->program].rt2_enabled = atoi(arg);
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_rtper(char *arg, RDSModulator* mod, char* output) { static void handle_rtper(char *arg, RDSModulator* mod, char* output) {
mod->enc->data[mod->enc->program].rt_switching_period = atoi(arg); mod->enc->data[mod->enc->program].rt_switching_period = atoi(arg);
mod->enc->state[mod->enc->program].rt_switching_period_state = mod->enc->data[mod->enc->program].rt_switching_period; mod->enc->state[mod->enc->program].rt_switching_period_state = mod->enc->data[mod->enc->program].rt_switching_period;
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_ptynen(char *arg, RDSModulator* mod, char* output) { static void handle_ptynen(char *arg, RDSModulator* mod, char* output) {
mod->enc->data[mod->enc->program].ptyn_enabled = atoi(arg); mod->enc->data[mod->enc->program].ptyn_enabled = atoi(arg);
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_rtprun(char *arg, RDSModulator* mod, char* output) { static void handle_rtprun(char *arg, RDSModulator *mod, char *output) {
int flag1, flag2; int flag1 = 0, flag2 = 0;
if (sscanf(arg, "%d,%d", &flag1, &flag2) == 2) { if (sscanf(arg, "%d,%d", &flag1, &flag2) < 1) flag1 = atoi(arg);
set_rds_rtplus_flags(mod->enc, flag1); mod->enc->rtpData[mod->enc->program][0].enabled = (flag1 == 2);
if(flag2) mod->enc->rtpState[mod->enc->program][0].toggle ^= 1; mod->enc->rtpData[mod->enc->program][0].running = flag1 & 1;
} else set_rds_rtplus_flags(mod->enc, atoi(arg)); if (flag2) mod->enc->rtpState[mod->enc->program][0].toggle ^= 1;
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_ertprun(char *arg, RDSModulator* mod, char* output) { static void handle_ertprun(char *arg, RDSModulator* mod, char* output) {
int flag1, flag2; int flag1 = 0, flag2 = 0;
if (sscanf(arg, "%d,%d", &flag1, &flag2) == 2) { if (sscanf(arg, "%d,%d", &flag1, &flag2) < 1) flag1 = atoi(arg);
set_rds_ertplus_flags(mod->enc, flag1); mod->enc->rtpData[mod->enc->program][1].enabled = (flag1 == 2);
if(flag2) mod->enc->rtpState[mod->enc->program][1].toggle ^= 1; mod->enc->rtpData[mod->enc->program][1].running = flag1 & 1;
} else set_rds_ertplus_flags(mod->enc, atoi(arg)); if (flag2) mod->enc->rtpState[mod->enc->program][1].toggle ^= 1;
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_program(char *arg, RDSModulator* mod, char* output) { static void handle_program(char *arg, RDSModulator* mod, char* output) {
@@ -294,12 +287,12 @@ static void handle_program(char *arg, RDSModulator* mod, char* output) {
mod->enc->data[mod->enc->program].ta = 0; mod->enc->data[mod->enc->program].ta = 0;
mod->enc->data[(uint8_t)program].ta = 0; mod->enc->data[(uint8_t)program].ta = 0;
mod->enc->program = (uint8_t)program; mod->enc->program = (uint8_t)program;
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_rds2mod(char *arg, RDSModulator* mod, char* output) { static void handle_rds2mod(char *arg, RDSModulator* mod, char* output) {
mod->enc->encoder_data.rds2_mode = atoi(arg); mod->enc->encoder_data.rds2_mode = atoi(arg);
strcpy(output, "+\0"); strcpy(output, "+");
} }
static void handle_grpseq(char *arg, RDSModulator* mod, char* output) { static void handle_grpseq(char *arg, RDSModulator* mod, char* output) {
@@ -417,7 +410,7 @@ static void handle_init(char *arg, RDSModulator* mod, char* output) {
static void handle_ver(char *arg, RDSModulator* mod, char* output) { static void handle_ver(char *arg, RDSModulator* mod, char* output) {
(void)arg; (void)arg;
(void)mod; (void)mod;
sprintf(output, "RDS95 v. %s - (C) 2025 radio95", VERSION); sprintf(output, "rds95 v. %s - (C) 2025 radio95", VERSION);
} }
static void handle_eonen(char *arg, char *pattern, RDSModulator* mod, char* output) { static void handle_eonen(char *arg, char *pattern, RDSModulator* mod, char* output) {
@@ -620,9 +613,7 @@ void process_ascii_cmd(RDSModulator* mod, char *str, char *cmd_output) {
break; break;
} }
} }
if(!reached) { if(!reached) return;
return;
}
} }
if(mod->enc->encoder_data.ascii_data.expected_site_addr != 0) { if(mod->enc->encoder_data.ascii_data.expected_site_addr != 0) {
uint8_t reached = 0; uint8_t reached = 0;
@@ -632,9 +623,7 @@ void process_ascii_cmd(RDSModulator* mod, char *str, char *cmd_output) {
break; break;
} }
} }
if(!reached) { if(!reached) return;
return;
}
} }
char *cmd, *arg; char *cmd, *arg;

2
src/ascii_cmd.h
View File

@@ -4,6 +4,6 @@
#include "lib.h" #include "lib.h"
#define CMD_BUFFER_SIZE 255 #define CMD_BUFFER_SIZE 255
#define CTL_BUFFER_SIZE (CMD_BUFFER_SIZE * 2) #define CTL_BUFFER_SIZE (CMD_BUFFER_SIZE * 2)
#define READ_TIMEOUT_MS 200 #define READ_TIMEOUT_MS 225
void process_ascii_cmd(RDSModulator* mod, char *str, char *cmd_output); void process_ascii_cmd(RDSModulator* mod, char *str, char *cmd_output);

9
src/lib.c
View File

@@ -14,7 +14,6 @@ int _strnlen(const char *s, int maxlen) {
return len; return len;
} }
// For RDS2 RFT, file error checking, and UECP
uint16_t crc16_ccitt(char* data, uint16_t len) { uint16_t crc16_ccitt(char* data, uint16_t len) {
uint16_t i, crc=0xFFFF; uint16_t i, crc=0xFFFF;
for (i=0; i < len; i++ ) { for (i=0; i < len; i++ ) {
@@ -27,7 +26,7 @@ uint16_t crc16_ccitt(char* data, uint16_t len) {
return ((crc ^= 0xFFFF) & 0xFFFF); return ((crc ^= 0xFFFF) & 0xFFFF);
} }
uint16_t get_block_grom_group(RDSGroup *group, uint8_t block) { uint16_t get_block_from_group(RDSGroup *group, uint8_t block) {
switch (block) { switch (block) {
case 0: return group->a; case 0: return group->a;
case 1: return group->b; case 1: return group->b;
@@ -53,7 +52,7 @@ void add_checkwords(RDSGroup *group, uint8_t *bits)
offset_word = offset_words[i]; offset_word = offset_words[i];
if (i == 2 && group->is_type_b) offset_word = offset_words[4]; if (i == 2 && group->is_type_b) offset_word = offset_words[4];
uint16_t block = get_block_grom_group(group, i); uint16_t block = get_block_from_group(group, i);
uint16_t block_crc = 0; uint16_t block_crc = 0;
uint8_t j, bit, msb; uint8_t j, bit, msb;
@@ -65,9 +64,7 @@ void add_checkwords(RDSGroup *group, uint8_t *bits)
*bits++ = bit; *bits++ = bit;
} }
uint16_t check = block_crc ^ offset_word; uint16_t check = block_crc ^ offset_word;
for (j = 0; j < POLY_DEG; j++) { for (j = 0; j < POLY_DEG; j++) *bits++ = (check & ((1 << (POLY_DEG - 1)) >> j)) != 0;
*bits++ = (check & ((1 << (POLY_DEG - 1)) >> j)) != 0;
}
} }
} }

2
src/lib.h
View File

@@ -8,7 +8,7 @@ int _strnlen(const char *s, int maxlen);
uint16_t crc16_ccitt(char *data, uint16_t len); uint16_t crc16_ccitt(char *data, uint16_t len);
uint16_t get_block_grom_group(RDSGroup *group, uint8_t block); uint16_t get_block_from_group(RDSGroup *group, uint8_t block);
void add_checkwords(RDSGroup *group, uint8_t *bits); void add_checkwords(RDSGroup *group, uint8_t *bits);
uint8_t add_rds_af_oda(RDSAFsODA *af_list, float freq); uint8_t add_rds_af_oda(RDSAFsODA *af_list, float freq);

50
src/rds.c
View File

@@ -167,7 +167,6 @@ static void get_rds_ps_group(RDSEncoder* enc, RDSGroup *group) {
static void get_rds_fasttuning_group(RDSEncoder* enc, RDSGroup *group) { static void get_rds_fasttuning_group(RDSEncoder* enc, RDSGroup *group) {
group->b |= 15 << 12; group->b |= 15 << 12;
group->b |= 1 << 11; group->b |= 1 << 11;
group->is_type_b = 1; group->is_type_b = 1;
@@ -205,8 +204,7 @@ static void get_rds_rt_group(RDSEncoder* enc, RDSGroup *group) {
case 1: case 1:
ab = (enc->data[enc->program].current_rt == 0) ? 0 : 1; ab = (enc->data[enc->program].current_rt == 0) ? 0 : 1;
break; break;
default: default: break;
break;
} }
group->b |= 2 << 12; group->b |= 2 << 12;
@@ -221,23 +219,20 @@ static void get_rds_rt_group(RDSEncoder* enc, RDSGroup *group) {
enc->state[enc->program].rt_state++; enc->state[enc->program].rt_state++;
if (enc->state[enc->program].rt_state == segments) enc->state[enc->program].rt_state = 0; if (enc->state[enc->program].rt_state == segments) enc->state[enc->program].rt_state = 0;
} }
static void get_rds_rtp_oda_group(RDSEncoder* enc, RDSGroup *group) { static void get_rdsp_rtp_oda_group(RDSGroup *group) {
(void)enc;
group->b |= 3 << 12; group->b |= 3 << 12;
group->b |= 11 << 1; group->b |= 11 << 1;
group->d = ODA_AID_RTPLUS; group->d = ODA_AID_RTPLUS;
} }
static void get_rds_ertp_oda_group(RDSEncoder* enc, RDSGroup *group) { static void get_rdsp_ertp_oda_group(RDSGroup *group) {
(void)enc;
group->b |= 3 << 12; group->b |= 3 << 12;
group->b |= 13 << 1; group->b |= 13 << 1;
group->d = ODA_AID_ERTPLUS; group->d = ODA_AID_ERTPLUS;
} }
static void get_rds_ert_oda_group(RDSEncoder* enc, RDSGroup *group) { static void get_rdsp_ert_oda_group(RDSGroup *group) {
(void)enc;
group->b |= 3 << 12; group->b |= 3 << 12;
group->b |= 12 << 1; group->b |= 12 << 1;
@@ -245,15 +240,14 @@ static void get_rds_ert_oda_group(RDSEncoder* enc, RDSGroup *group) {
group->d = ODA_AID_ERT; group->d = ODA_AID_ERT;
} }
static void get_oda_af_oda_group(RDSEncoder* enc, RDSGroup *group) { static void get_rdsp_oda_af_oda_group( RDSGroup *group) {
(void)enc;
group->b |= 3 << 12; group->b |= 3 << 12;
group->b |= 7 << 1; group->b |= 7 << 1;
group->d = ODA_AID_ODAAF; group->d = ODA_AID_ODAAF;
} }
static void get_oda_af_group(RDSEncoder* enc, RDSGroup *group) { static void get_rds_oda_af_group(RDSEncoder* enc, RDSGroup *group) {
uint16_t af[4]; uint16_t af[4];
get_next_af_oda(enc, af); get_next_af_oda(enc, af);
@@ -271,15 +265,12 @@ static void get_oda_af_group(RDSEncoder* enc, RDSGroup *group) {
group->d |= af[3] & 0xFF; group->d |= af[3] & 0xFF;
} }
static void get_rds_ct_group(RDSEncoder* enc, RDSGroup *group) { static void get_rdsp_ct_group(RDSGroup *group, time_t now) {
(void)enc;
struct tm *utc, *local_time; struct tm *utc, *local_time;
time_t now;
uint8_t l; uint8_t l;
uint32_t mjd; uint32_t mjd;
int16_t offset; int16_t offset;
now = time(NULL);
utc = gmtime(&now); utc = gmtime(&now);
l = utc->tm_mon <= 1 ? 1 : 0; l = utc->tm_mon <= 1 ? 1 : 0;
@@ -540,17 +531,17 @@ static void get_rds_sequence_group(RDSEncoder* enc, RDSGroup *group, char* grp,
break; break;
case 'R': case 'R':
if(enc->state[enc->program].rtp_oda == 0) get_rds_rtplus_group(enc, group); if(enc->state[enc->program].rtp_oda == 0) get_rds_rtplus_group(enc, group);
else get_rds_rtp_oda_group(enc, group); else get_rdsp_rtp_oda_group(group);
enc->state[enc->program].rtp_oda ^= 1; enc->state[enc->program].rtp_oda ^= 1;
break; break;
case 'P': case 'P':
if(enc->state[enc->program].ert_oda == 0) get_rds_ertplus_group(enc, group); if(enc->state[enc->program].ert_oda == 0) get_rds_ertplus_group(enc, group);
else get_rds_ertp_oda_group(enc, group); else get_rdsp_ertp_oda_group(group);
enc->state[enc->program].ert_oda ^= 1; enc->state[enc->program].ert_oda ^= 1;
break; break;
case 'S': case 'S':
if(enc->state[enc->program].ert_oda == 0) get_rds_ert_group(enc, group); if(enc->state[enc->program].ert_oda == 0) get_rds_ert_group(enc, group);
else get_rds_ert_oda_group(enc, group); else get_rdsp_ert_oda_group(group);
enc->state[enc->program].ert_oda ^= 1; enc->state[enc->program].ert_oda ^= 1;
break; break;
case 'F': case 'F':
@@ -560,8 +551,8 @@ static void get_rds_sequence_group(RDSEncoder* enc, RDSGroup *group, char* grp,
get_rds_fasttuning_group(enc, group); get_rds_fasttuning_group(enc, group);
break; break;
case 'U': case 'U':
if(enc->state[enc->program].af_oda == 0) get_oda_af_group(enc, group); if(enc->state[enc->program].af_oda == 0) get_rds_oda_af_group(enc, group);
else get_oda_af_oda_group(enc, group); else get_rdsp_oda_af_oda_group(group);
enc->state[enc->program].af_oda ^= 1; enc->state[enc->program].af_oda ^= 1;
break; break;
} }
@@ -606,6 +597,7 @@ static void get_rds_group(RDSEncoder* enc, RDSGroup *group, uint8_t stream) {
if (utc->tm_min != enc->state[enc->program].last_minute) { if (utc->tm_min != enc->state[enc->program].last_minute) {
enc->state[enc->program].last_minute = utc->tm_min; enc->state[enc->program].last_minute = utc->tm_min;
uint8_t eon_has_ta = 0; uint8_t eon_has_ta = 0;
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
if (enc->data[enc->program].eon[i].enabled && enc->data[enc->program].eon[i].ta) { if (enc->data[enc->program].eon[i].enabled && enc->data[enc->program].eon[i].ta) {
@@ -644,7 +636,7 @@ static void get_rds_group(RDSEncoder* enc, RDSGroup *group, uint8_t stream) {
} }
if(enc->data[enc->program].ct && stream == 0) { if(enc->data[enc->program].ct && stream == 0) {
get_rds_ct_group(enc, group); get_rdsp_ct_group(group, now);
goto group_coded; goto group_coded;
} }
} }
@@ -662,7 +654,7 @@ static void get_rds_group(RDSEncoder* enc, RDSGroup *group, uint8_t stream) {
group->b = enc->state[enc->program].last_stream0_group[0]; group->b = enc->state[enc->program].last_stream0_group[0];
group->c = enc->state[enc->program].last_stream0_group[1]; group->c = enc->state[enc->program].last_stream0_group[1];
group->d = enc->state[enc->program].last_stream0_group[2]; group->d = enc->state[enc->program].last_stream0_group[2];
group->is_type_b = (group->a == 0 && IS_TYPE_B(group->b)); group->is_type_b = enc->state[enc->program].last_stream0_group_type_b;
goto group_coded_rds2; goto group_coded_rds2;
} else if(enc->encoder_data.rds2_mode == 1) { } else if(enc->encoder_data.rds2_mode == 1) {
while(good_group == 0) { while(good_group == 0) {
@@ -677,6 +669,7 @@ static void get_rds_group(RDSEncoder* enc, RDSGroup *group, uint8_t stream) {
if(!good_group) cant_find_group++; if(!good_group) cant_find_group++;
else cant_find_group = 0; else cant_find_group = 0;
if(!good_group && cant_find_group == 23) { if(!good_group && cant_find_group == 23) {
cant_find_group = 0; cant_find_group = 0;
break; break;
@@ -734,6 +727,7 @@ group_coded:
enc->state[enc->program].last_stream0_group[0] = group->b; enc->state[enc->program].last_stream0_group[0] = group->b;
enc->state[enc->program].last_stream0_group[1] = group->c; enc->state[enc->program].last_stream0_group[1] = group->c;
enc->state[enc->program].last_stream0_group[2] = group->d; enc->state[enc->program].last_stream0_group[2] = group->d;
enc->state[enc->program].last_stream0_group_type_b = group->is_type_b;
return; return;
} }
@@ -910,16 +904,6 @@ void set_rds_ert(RDSEncoder* enc, char *ert) {
} else enc->state[enc->program].ert_segments = 32; } else enc->state[enc->program].ert_segments = 32;
} }
void set_rds_rtplus_flags(RDSEncoder* enc, uint8_t flags) {
enc->rtpData[enc->program][0].enabled = (flags==2);
enc->rtpData[enc->program][0].running = flags & 1;
}
void set_rds_ertplus_flags(RDSEncoder* enc, uint8_t flags) {
enc->rtpData[enc->program][1].enabled = (flags==2);
enc->rtpData[enc->program][1].running = flags & 1;
}
void set_rds_rtplus_tags(RDSEncoder* enc, uint8_t *tags) { void set_rds_rtplus_tags(RDSEncoder* enc, uint8_t *tags) {
enc->rtpData[enc->program][0].type[0] = tags[0] & 0x3f; enc->rtpData[enc->program][0].type[0] = tags[0] & 0x3f;
enc->rtpData[enc->program][0].start[0] = tags[1] & 0x3f; enc->rtpData[enc->program][0].start[0] = tags[1] & 0x3f;

4
src/rds.h
View File

@@ -173,6 +173,7 @@ typedef struct {
uint8_t eon_linkage : 1; uint8_t eon_linkage : 1;
uint16_t last_stream0_group[3]; uint16_t last_stream0_group[3];
uint8_t last_stream0_group_type_b : 1;
} RDSState; } RDSState;
typedef struct { typedef struct {
@@ -242,14 +243,13 @@ void reset_rds_state(RDSEncoder* enc, uint8_t program);
void set_rds_defaults(RDSEncoder* enc, uint8_t program); void set_rds_defaults(RDSEncoder* enc, uint8_t program);
void init_rds_encoder(RDSEncoder* enc); void init_rds_encoder(RDSEncoder* enc);
void get_rds_bits(RDSEncoder* enc, uint8_t *bits, uint8_t stream); void get_rds_bits(RDSEncoder* enc, uint8_t *bits, uint8_t stream);
void set_rds_rt1(RDSEncoder* enc, char *rt1); void set_rds_rt1(RDSEncoder* enc, char *rt1);
void set_rds_rt2(RDSEncoder* enc, char *rt2); void set_rds_rt2(RDSEncoder* enc, char *rt2);
void set_rds_ps(RDSEncoder* enc, char *ps); void set_rds_ps(RDSEncoder* enc, char *ps);
void set_rds_tps(RDSEncoder* enc, char *tps); void set_rds_tps(RDSEncoder* enc, char *tps);
void set_rds_lps(RDSEncoder* enc, char *lps); void set_rds_lps(RDSEncoder* enc, char *lps);
void set_rds_ert(RDSEncoder *enc, char *ert); void set_rds_ert(RDSEncoder *enc, char *ert);
void set_rds_rtplus_flags(RDSEncoder *enc, uint8_t flags);
void set_rds_ertplus_flags(RDSEncoder *enc, uint8_t flags);
void set_rds_rtplus_tags(RDSEncoder *enc, uint8_t *tags); void set_rds_rtplus_tags(RDSEncoder *enc, uint8_t *tags);
void set_rds_ertplus_tags(RDSEncoder *enc, uint8_t *tags); void set_rds_ertplus_tags(RDSEncoder *enc, uint8_t *tags);
void set_rds_ptyn(RDSEncoder *enc, char *ptyn); void set_rds_ptyn(RDSEncoder *enc, char *ptyn);