radio95/rds95
0
1
Fork 0
mirror of https://github.com/radio95-rnt/rds95.git synced 2026-02-26 20:33:53 +01:00
Code Issues Wiki Activity

some memory optimizations and add data for ERT

Browse Source
This commit is contained in:
KubaPro010
2025-03-28 20:26:49 +01:00
parent 28b3c5e9be
commit f76e946c7f
6 changed files with 107 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.vscode/.server-controller-port.log vendored
View File

@@ -1,5 +1,5 @@
{
"port": 13452,
"time": 1742919666758,
"time": 1743187937799,
"version": "0.0.3"
}

49
doc.md
View File

@@ -111,4 +111,51 @@ Sends a custom group to the next group available: `G=F100FFFFFFFF` or `G=0000200
Enables RT 1: `RT1EN=1`
TODO: Rest of commands
### RT2EN
Enables RT 2: `RT1EN=2`
### RTPER
RT Switching period, in minutes: `RTPER=5`
### LEVEL
Sets the RDS output level: `LEVEL=255`
### RESET
Resets the internal state of the encoder: `RESET`
### PTYNEN
Enables PTYN: `PTYNEN=1`
### GRPSEQ
Sets the group sequence for stream0, available groups:
- 0: 4 PSs
- 1: ECC
- 2: RT
- A: PTYN
- E: EON
- X: UDG1
- Y: UDG2
- R: RT+
- 3: ODA
- F: LPS
`GRPSEQ=002222`
### RDSGEN
Sets the rds generator level:
- 0: No streams
- 1: Stream 0 only
- 2: Stream 0 and 1
`RDSGEN=1`
TODO: Rest of the cmds

2
src/ascii_cmd.c
View File

@@ -432,7 +432,6 @@ static const command_handler_t commands_eq6[] = {
{"RT2EN", handle_rt2en, 5},
{"RTPER", handle_rtper, 5},
{"LEVEL", handle_level, 5},
{"RESET", handle_reset, 5},
};
static const command_handler_t commands_eq7[] = {
@@ -451,6 +450,7 @@ static const command_handler_t commands_eq8[] = {
static const command_handler_t commands_exact[] = {
{"INIT", handle_init, 4},
{"VER", handle_ver, 3},
{"RESET", handle_reset, 5},
// TODO: handle help, status
};

2
src/modulator.h
View File

@@ -3,8 +3,6 @@
#include "rds.h"
#include "waveforms.h"
#define STREAMS 2
typedef struct
{
float level;

62
src/rds.c
View File

@@ -84,8 +84,8 @@ void saveToFile(RDSEncoder *emp, const char *option) {
} else if (strcmp(option, "ALL") == 0) {
memcpy(&(tempEncoder.data[emp->program]), &(emp->data[emp->program]), sizeof(RDSData));
memcpy(&(tempEncoder.rtpData[emp->program]), &(emp->rtpData[emp->program]), sizeof(RDSRTPlusData));
memcpy(&(tempEncoder.odas[emp->program]), &(emp->odas[emp->program]), sizeof(RDSODA)*MAX_ODAS);
memcpy(&(tempEncoder.oda_state[emp->program]), &(emp->oda_state[emp->program]), sizeof(RDSODAState));
memcpy(&(tempEncoder.odas[emp->program]), &(emp->odas[emp->program]), sizeof(RDSODA)*MAX_ODAS*STREAMS);
memcpy(&(tempEncoder.oda_state[emp->program]), &(emp->oda_state[emp->program]), sizeof(RDSODAState)*STREAMS);
memcpy(&(tempEncoder.encoder_data), &(emp->encoder_data), sizeof(RDSEncoderData));
tempEncoder.program = emp->program;
} else {
@@ -98,8 +98,8 @@ void saveToFile(RDSEncoder *emp, const char *option) {
rdsEncoderfile.file_ender = 95;
memcpy(&(rdsEncoderfile.data[emp->program]), &(tempEncoder.data[emp->program]), sizeof(RDSData));
memcpy(&(rdsEncoderfile.rtpData[emp->program]), &(tempEncoder.rtpData[emp->program]), sizeof(RDSRTPlusData));
memcpy(&(rdsEncoderfile.odas[emp->program]), &(tempEncoder.odas[emp->program]), sizeof(RDSODA)*MAX_ODAS);
memcpy(&(rdsEncoderfile.oda_state[emp->program]), &(tempEncoder.oda_state[emp->program]), sizeof(RDSODAState));
memcpy(&(rdsEncoderfile.odas[emp->program]), &(tempEncoder.odas[emp->program]), sizeof(RDSODA)*MAX_ODAS*STREAMS);
memcpy(&(rdsEncoderfile.oda_state[emp->program]), &(tempEncoder.oda_state[emp->program]), sizeof(RDSODAState)*STREAMS);
memcpy(&(rdsEncoderfile.encoder_data), &(tempEncoder.encoder_data), sizeof(RDSEncoderData));
rdsEncoderfile.program = tempEncoder.program;
@@ -133,8 +133,8 @@ void loadFromFile(RDSEncoder *enc) {
for (int i = 0; i < PROGRAMS; i++) {
memcpy(&(enc->data[i]), &(rdsEncoderfile.data[i]), sizeof(RDSData));
memcpy(&(enc->rtpData[i]), &(rdsEncoderfile.rtpData[i]), sizeof(RDSRTPlusData));
memcpy(&(enc->odas[i]), &(rdsEncoderfile.odas[i]), sizeof(RDSODA) * MAX_ODAS);
memcpy(&(enc->oda_state[i]), &(rdsEncoderfile.oda_state[i]), sizeof(RDSODAState));
memcpy(&(enc->odas[i]), &(rdsEncoderfile.odas[i]), sizeof(RDSODA) * MAX_ODAS * STREAMS);
memcpy(&(enc->oda_state[i]), &(rdsEncoderfile.oda_state[i]), sizeof(RDSODAState) * STREAMS);
}
memcpy(&(enc->encoder_data), &(rdsEncoderfile.encoder_data), sizeof(RDSEncoderData));
enc->program = rdsEncoderfile.program;
@@ -151,12 +151,12 @@ int rdssaved() {
return 0;
}
// static void register_oda(RDSEncoder* enc, uint8_t group, uint16_t aid, uint16_t scb) {
// static void register_oda(RDSEncoder* enc, uint8_t stream, uint8_t group, uint16_t aid, uint16_t data) {
// if (enc->oda_state[enc->program].count >= MAX_ODAS) return;
// enc->odas[enc->program][enc->oda_state[enc->program].count].group = group;
// enc->odas[enc->program][enc->oda_state[enc->program].count].aid = aid;
// enc->odas[enc->program][enc->oda_state[enc->program].count].scb = scb;
// enc->odas[enc->program][stream][enc->oda_state[enc->program].count].group = group;
// enc->odas[enc->program][stream][enc->oda_state[enc->program].count].aid = aid;
// enc->odas[enc->program][stream][enc->oda_state[enc->program].count].data = data;
// enc->oda_state[enc->program].count++;
// }
@@ -211,7 +211,7 @@ static void get_rds_ps_group(RDSEncoder* enc, uint16_t *blocks) {
}
enc->state[enc->program].ps_csegment++;
if (enc->state[enc->program].ps_csegment >= 4) enc->state[enc->program].ps_csegment = 0;
if (enc->state[enc->program].ps_csegment == 3) enc->state[enc->program].ps_csegment = 0;
}
static void get_rds_rt_group(RDSEncoder* enc, uint16_t *blocks) {
@@ -252,23 +252,23 @@ static void get_rds_rt_group(RDSEncoder* enc, uint16_t *blocks) {
blocks[3] = enc->state[enc->program].rt_text[enc->state[enc->program].rt_state * 4 + 2] << 8;
blocks[3] |= enc->state[enc->program].rt_text[enc->state[enc->program].rt_state * 4 + 3];
enc->state[enc->program].rt_state++;
uint8_t segments = (enc->state[enc->program].current_rt == 1) ? enc->state[enc->program].rt2_segments : enc->state[enc->program].rt_segments;
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;
enc->state[enc->program].rt_state++;
}
static void get_rds_oda_group(RDSEncoder* enc, uint16_t *blocks) {
RDSODA this_oda = enc->odas[enc->program][enc->oda_state[enc->program].current];
static void get_rds_oda_group(RDSEncoder* enc, uint16_t *blocks, uint8_t stream) {
RDSODA this_oda = enc->odas[enc->program][stream][enc->oda_state[enc->program][stream].current];
blocks[1] |= 3 << 12;
blocks[1] |= GET_GROUP_TYPE(this_oda.group) << 1;
blocks[1] |= GET_GROUP_VER(this_oda.group);
blocks[2] = this_oda.scb;
blocks[2] = this_oda.data;
blocks[3] = this_oda.aid;
enc->oda_state[enc->program].current++;
if (enc->oda_state[enc->program].current >= enc->oda_state[enc->program].count) enc->oda_state[enc->program].current = 0;
if (enc->oda_state[enc->program][stream].current == enc->oda_state[enc->program][stream].count) enc->oda_state[enc->program][stream].current = 0;
enc->oda_state[enc->program][stream].current++;
}
static void get_rds_rtp_oda_group(RDSEncoder* enc, uint16_t *blocks) {
@@ -482,7 +482,7 @@ static void get_rds_sequence_group(RDSEncoder* enc, uint16_t *blocks, char* grp,
goto group_coded;
// TODO: add uecp
case '3':
get_rds_oda_group(enc, blocks);
get_rds_oda_group(enc, blocks, stream);
goto group_coded;
case 'F':
get_rds_lps_group(enc, blocks);
@@ -492,7 +492,7 @@ group_coded:
return;
}
static uint8_t check_rds_good_group(RDSEncoder* enc, char* grp) {
static uint8_t check_rds_good_group(RDSEncoder* enc, char* grp, uint8_t stream) {
uint8_t good_group = 0;
if(*grp == '0') good_group = 1;
if(*grp == '1' && enc->data[enc->program].ecc != 0) good_group = 1;
@@ -509,7 +509,7 @@ static uint8_t check_rds_good_group(RDSEncoder* enc, char* grp) {
if(*grp == 'X' && enc->data[enc->program].udg1_len != 0) good_group = 1;
if(*grp == 'Y' && enc->data[enc->program].udg2_len != 0) good_group = 1;
if(*grp == 'R' && enc->rtpData[enc->program].enabled) good_group = 1;
if(*grp == '3' && enc->oda_state[enc->program].count != 0) good_group = 1;
if(*grp == '3' && enc->oda_state[enc->program][stream].count != 0) good_group = 1;
if(*grp == 'F' && enc->data[enc->program].lps[0] != '\0') good_group = 1;
return good_group;
}
@@ -586,7 +586,7 @@ static void get_rds_group(RDSEncoder* enc, uint16_t *blocks, uint8_t stream) {
}
grp = enc->data[enc->program].grp_sqc_rds2[grp_sqc_idx];
good_group = check_rds_good_group(enc, &grp);
good_group = check_rds_good_group(enc, &grp, stream);
if(!good_group) cant_find_group++;
else cant_find_group = 0;
@@ -617,7 +617,7 @@ static void get_rds_group(RDSEncoder* enc, uint16_t *blocks, uint8_t stream) {
}
grp = enc->data[enc->program].grp_sqc[grp_sqc_idx];
good_group = check_rds_good_group(enc, &grp);
good_group = check_rds_good_group(enc, &grp, stream);
if(!good_group) cant_find_group++;
else cant_find_group = 0;
@@ -702,8 +702,8 @@ void reset_rds_state(RDSEncoder* enc, uint8_t program) {
void set_rds_defaults(RDSEncoder* enc, uint8_t program) {
memset(&(enc->data[program]), 0, sizeof(RDSData));
memset(&(enc->oda_state[program]), 0, sizeof(RDSODAState));
memset(&(enc->odas[program]), 0, sizeof(RDSODA)*MAX_ODAS);
memset(&(enc->oda_state[program]), 0, sizeof(RDSODAState)*STREAMS);
memset(&(enc->odas[program]), 0, sizeof(RDSODA)*MAX_ODAS*STREAMS);
memset(&(enc->rtpData[program]), 0, sizeof(RDSRTPlusData));
memset(&(enc->encoder_data), 0, sizeof(RDSEncoderData));
@@ -764,10 +764,10 @@ void set_rds_rt1(RDSEncoder* enc, char *rt1) {
while (i < len) {
i += 4;
enc->state[enc->program].rt_segments++;
if (i != 4) enc->state[enc->program].rt_segments++;
}
} else {
enc->state[enc->program].rt_segments = 16;
enc->state[enc->program].rt_segments = 15;
}
}
@@ -790,10 +790,10 @@ void set_rds_rt2(RDSEncoder* enc, char *rt2) {
while (i < len) {
i += 4;
enc->state[enc->program].rt2_segments++;
if (i != 4) enc->state[enc->program].rt2_segments++;
}
} else {
enc->state[enc->program].rt2_segments = 16;
enc->state[enc->program].rt2_segments = 15;
}
}
@@ -834,10 +834,10 @@ void set_rds_lps(RDSEncoder* enc, char *lps) {
while (i < len) {
i += 4;
enc->state[enc->program].lps_segments++;
if (i != 4) enc->state[enc->program].lps_segments++;
}
} else {
enc->state[enc->program].lps_segments = 8;
enc->state[enc->program].lps_segments = 7;
}
}

53
src/rds.h
View File

@@ -15,7 +15,10 @@
#define FILTER_SIZE 64
#define SAMPLE_BUFFER_SIZE (SAMPLES_PER_BIT + FILTER_SIZE)
#define STREAMS 2
#define RT_LENGTH 64
#define ERT_LENGTH 128
#define PS_LENGTH 8
#define PTYN_LENGTH 8
#define LPS_LENGTH 32
@@ -48,19 +51,6 @@ typedef struct {
char ps[8];
RDSAFs af;
} RDSEON;
typedef struct
{
uint8_t days : 7; // let's say that here it will be stored by bits, so 0b1000000 is monday and so on
uint8_t pty: 5;
uint16_t execution_hours[12];
uint16_t execution_minutes[12];
char command[35];
} RDSSchedulerItem;
typedef struct
{
uint8_t enabled : 1;
RDSSchedulerItem items[49];
} RDSScheduler;
typedef struct {
uint16_t pi;
@@ -83,11 +73,18 @@ typedef struct {
uint8_t rt2_enabled : 1;
uint8_t rt_type : 2;
uint8_t rt_text_timeout;
uint8_t original_rt_text_timeout;
uint8_t rt_switching_period;
uint8_t orignal_rt_switching_period;
char default_rt[RT_LENGTH];
char rt2[RT_LENGTH];
uint8_t ert_enabled : 1;
uint8_t ert_switching_period;
uint8_t orignal_ert_switching_period;
char ert[ERT_LENGTH];
char ert2[ERT_LENGTH];
uint8_t ptyn_enabled : 1;
char ptyn[PTYN_LENGTH];
@@ -114,26 +111,29 @@ typedef struct {
uint8_t tps_update : 1;
char ps_text[PS_LENGTH];
char tps_text[PS_LENGTH];
uint8_t ps_csegment : 4;
uint8_t ps_csegment : 2;
char rt_text[RT_LENGTH];
uint8_t rt_state : 5;
uint8_t rt_state : 4;
uint8_t rt_update : 1;
uint8_t rt2_update : 1;
uint8_t rt_ab : 1;
uint8_t rt_segments : 5;
uint8_t rt2_segments : 5;
uint8_t rt_segments : 4;
uint8_t rt2_segments : 4;
uint8_t current_rt : 1;
char ert_text[ERT_LENGTH];
// uint8_t ert_state
char ptyn_text[PTYN_LENGTH];
uint8_t ptyn_state : 1;
uint8_t ptyn_update : 1;
uint8_t ptyn_ab : 1;
char lps_text[LPS_LENGTH];
uint8_t lps_state : 5;
uint8_t lps_state : 3;
uint8_t lps_update : 1;
uint8_t lps_segments : 5;
uint8_t lps_segments : 3;
uint16_t custom_group[GROUP_LENGTH];
uint16_t custom_group2[GROUP_LENGTH + 1];
@@ -155,11 +155,11 @@ typedef struct {
typedef struct {
uint8_t group;
uint16_t aid;
uint16_t scb;
uint16_t data;
} RDSODA;
typedef struct {
uint8_t current : 4;
uint8_t count : 4;
uint8_t current : 3;
uint8_t count : 3;
} RDSODAState;
typedef struct {
@@ -189,7 +189,6 @@ typedef struct {
RDSEncoderASCIIData ascii_data;
RDSEncoderUECPData uecp_data;
uint16_t special_features;
RDSScheduler schedule;
uint8_t rds2_mode : 1;
// uint8_t rds2_buffer[16384];
} RDSEncoderData;
@@ -197,8 +196,8 @@ typedef struct {
RDSEncoderData encoder_data;
RDSData data[PROGRAMS];
RDSState state[PROGRAMS];
RDSODA odas[PROGRAMS][MAX_ODAS];
RDSODAState oda_state[PROGRAMS];
RDSODA odas[PROGRAMS][STREAMS][MAX_ODAS];
RDSODAState oda_state[PROGRAMS][STREAMS];
RDSRTPlusData rtpData[PROGRAMS];
RDSRTPlusState rtpState[PROGRAMS];
uint8_t program : 3;
@@ -207,9 +206,9 @@ typedef struct {
uint8_t file_starter; // Always is 225 first polish radio programme am frequency
RDSData data[PROGRAMS];
RDSRTPlusData rtpData[PROGRAMS];
RDSODA odas[PROGRAMS][MAX_ODAS];
RDSODA odas[PROGRAMS][STREAMS][MAX_ODAS];
uint8_t file_middle; // Always is 160, average of both
RDSODAState oda_state[PROGRAMS];
RDSODAState oda_state[PROGRAMS][STREAMS];
RDSEncoderData encoder_data;
uint8_t program : 3;
uint8_t file_ender; // Always is 95 my freq