kuba/TEF6686_ESP32
1
0
Fork 0
Code Issues Pull Requests Releases 1 Wiki Activity

internal changes, remove useless things

Browse Source
This commit is contained in:
KubaPro010
2026-01-13 21:13:10 +01:00
parent bbecc23b6b
commit 77b7f45d90
21 changed files with 201 additions and 1083 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
src/NTPupdate.cpp
View File

@@ -54,12 +54,7 @@ void NTPupdate() {
time_t currentTime = getNtpTime();
if (currentTime) {
rtc.setTime(currentTime);
if(rx_rtc_avail) {
RX8010SJ::DateTime rx_currenttime = RX8010SJ::DateTime();
timeToDateTime(currentTime, &rx_currenttime);
rx_rtc.writeDateTime(rx_currenttime);
}
set_time(currentTime);
rtcset = true;
NTPupdated = true;
radio.rds.ctupdate = false;

206
src/TEF6686.cpp
View File

@@ -1,13 +1,11 @@
#include "TEF6686.h"
#include <map>
#include <Arduino.h>
#include <TimeLib.h>
#include <SPIFFS.h>
#include "constants.h"
#include "utils.h"
unsigned long rdstimer = 0;
unsigned long bitStartTime = 0;
uint8_t dropped_groups = 0;
bool lastBitState = false;
uint16_t TEF6686::getBlockA(void) {
@@ -25,13 +23,13 @@ void TEF6686::TestAFEON() {
setMute();
for (int x = 0; x < af_counter; x++) {
timing = 0;
devTEF_Set_Cmd(TEF_FM, Cmd_Tune_To, 7, 3, af[x].frequency);
devTEF_Set_Cmd(TEF_FM, Cmd_Tune_To, 4, 3, af[x].frequency);
while (timing == 0 && !bitRead(timing, 15)) {
devTEF_Radio_Get_Quality_Status(&status, &aflevel, &afusn, &afwam, &afoffset, NULL, NULL, NULL);
timing = lowByte(status);
}
if (afoffset > -125 || afoffset < 125) {
devTEF_Set_Cmd(TEF_FM, Cmd_Tune_To, 7, 4, af[x].frequency);
devTEF_Set_Cmd(TEF_FM, Cmd_Tune_To, 4, 4, af[x].frequency);
delay(187);
devTEF_Radio_Get_RDS_Status(&rds.rdsStat, &rds.rdsA, &rds.rdsB, &rds.rdsC, &rds.rdsD, &rds.rdsErr);
@@ -47,7 +45,7 @@ void TEF6686::TestAFEON() {
}
}
}
devTEF_Set_Cmd(TEF_FM, Cmd_Tune_To, 7, 4, currentfreq);
devTEF_Set_Cmd(TEF_FM, Cmd_Tune_To, 4, 4, currentfreq);
setUnMute();
}
@@ -62,7 +60,7 @@ uint16_t TEF6686::TestAF() {
for (int x = 0; x < af_counter; x++) {
timing = 0;
devTEF_Set_Cmd(TEF_FM, Cmd_Tune_To, 7, 3, af[x].frequency);
devTEF_Set_Cmd(TEF_FM, Cmd_Tune_To, 4, 3, af[x].frequency);
while (timing == 0 && !bitRead(timing, 15)) {
devTEF_Radio_Get_Quality_Status(&status, &aflevel, &afusn, &afwam, &afoffset, NULL, NULL, NULL);
timing = lowByte(status);
@@ -82,7 +80,7 @@ uint16_t TEF6686::TestAF() {
}
if (af_counter != 0 && af[highestIndex].afvalid && af[highestIndex].score > (currentlevel - currentusn - currentwam) && (af[highestIndex].score - (currentlevel - currentusn - currentwam)) >= 70) {
devTEF_Set_Cmd(TEF_FM, Cmd_Tune_To, 7, 4, af[highestIndex].frequency);
devTEF_Set_Cmd(TEF_FM, Cmd_Tune_To, 4, 4, af[highestIndex].frequency);
delay(187);
devTEF_Radio_Get_RDS_Status(&rds.rdsStat, &rds.rdsA, &rds.rdsB, &rds.rdsC, &rds.rdsD, &rds.rdsErr);
if (bitRead(rds.rdsStat, 9)) {
@@ -97,9 +95,9 @@ uint16_t TEF6686::TestAF() {
af_counter = 0;
} else {
af[highestIndex].afvalid = false;
devTEF_Set_Cmd(TEF_FM, Cmd_Tune_To, 7, 4, currentfreq);
devTEF_Set_Cmd(TEF_FM, Cmd_Tune_To, 4, 4, currentfreq);
}
} else devTEF_Set_Cmd(TEF_FM, Cmd_Tune_To, 7, 4, currentfreq);
} else devTEF_Set_Cmd(TEF_FM, Cmd_Tune_To, 4, 4, currentfreq);
}
}
return currentfreq;
@@ -113,10 +111,11 @@ void TEF6686::init(byte TEF) {
uint32_t clock = 12000000;
#ifndef DEEPELEC_DP_66X
int xtalADC = analogRead(15);
if (xtalADC < XTAL_0V_ADC + XTAL_ADC_TOL) clock = 9216000;
else if (xtalADC > XTAL_1V_ADC - XTAL_ADC_TOL && xtalADC < XTAL_1V_ADC + XTAL_ADC_TOL);
else if (xtalADC > XTAL_2V_ADC - XTAL_ADC_TOL && xtalADC < XTAL_2V_ADC + XTAL_ADC_TOL) clock = 55466670;
int xtalMV = analogReadMilliVolts(15);
if (xtalMV < 0 + XTAL_MV_TOL) clock = 9216000;
else if (xtalMV > 1000 - XTAL_MV_TOL && xtalMV < 1000 + XTAL_MV_TOL);
else if (xtalMV > 2000 - XTAL_MV_TOL && xtalMV < 2000 + XTAL_MV_TOL) clock = 55466670;
else clock = 4000000;
#endif
@@ -124,26 +123,26 @@ void TEF6686::init(byte TEF) {
Tuner_Patch(TEF);
// Start the firmware
devTEF_Set_Cmd(TEF_INIT, 0, 3);
devTEF_Set_Cmd(TEF_INIT, 0, 0);
while(devTEF_APPL_Get_Operation_Status() != 1) delay(5); // Wait for it to load
if(clock != 9216000) devTEF_Set_Cmd(TEF_APPL, Cmd_Set_ReferenceClock, 9, (clock >> 16) & 0xffff, clock & 0xffff, (clock == 55466670) ? 1 : 0);
devTEF_Set_Cmd(TEF_APPL, Cmd_Set_Activate, 5, 1); // Setup done, start radio
if(clock != 9216000) devTEF_Set_Cmd(TEF_APPL, Cmd_Set_ReferenceClock, 6, (clock >> 16) & 0xffff, clock & 0xffff, (clock == 55466670) ? 1 : 0);
devTEF_Set_Cmd(TEF_APPL, Cmd_Set_Activate, 2, 1); // Setup done, start radio
while(devTEF_APPL_Get_Operation_Status() != 2) delay(5); // Wait for it to start
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Mph, 9, 0, 360, 300);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Max, 7, 0, 4000);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_LowCut_Max, 7, 0, 100);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Time, 11, 60, 120, 100, 200);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Time, 11, 500, 2000, 200, 200);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Level, 9, 0, 600, 240);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Noise, 9, 0, 160, 140);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Mph, 9, 0, 160, 140);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Max, 7, 0, 4000);
devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Ana_Out, 7, 128, 1);
devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Output_Source, 7, 128, 224);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Mph, 6, 0, 360, 300);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Max, 4, 0, 4000);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_LowCut_Max, 4, 0, 100);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Time, 8, 60, 120, 100, 200);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Time, 8, 500, 2000, 200, 200);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Level, 6, 0, 600, 240);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Noise, 6, 0, 160, 140);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Mph, 6, 0, 160, 140);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Max, 4, 0, 4000);
devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Ana_Out, 4, 128, 1);
devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Output_Source, 4, 128, 224);
}
void TEF6686::getIdentification(uint16_t *device, uint16_t *hw_version, uint16_t *sw_version) {
@@ -156,73 +155,73 @@ void TEF6686::getIdentification(uint16_t *device, uint16_t *hw_version, uint16_t
}
void TEF6686::power(bool mode) {
devTEF_Set_Cmd(TEF_APPL, Cmd_Set_OperationMode, 5, mode);
if (mode == 0) devTEF_Set_Cmd(TEF_FM, Cmd_Tune_To, 7, 1, 10000);
devTEF_Set_Cmd(TEF_APPL, Cmd_Set_OperationMode, 2, mode);
if (mode == 0) devTEF_Set_Cmd(TEF_FM, Cmd_Tune_To, 4, 1, 10000);
}
void TEF6686::extendBW(bool yesno) {
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Bandwidth_Options, 5, (yesno ? 400 : 950));
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Bandwidth_Options, 2, (yesno ? 400 : 950));
}
void TEF6686::SetFreq(uint16_t frequency) {
devTEF_Set_Cmd(TEF_FM, Cmd_Tune_To, 7, 4, frequency);
devTEF_Set_Cmd(TEF_FM, Cmd_Tune_To, 4, 4, frequency);
currentfreq = ((frequency + 5) / 10) * 10;
currentfreq2 = frequency;
}
void TEF6686::SetFreqAM(uint16_t frequency) {
devTEF_Set_Cmd(TEF_AM, Cmd_Tune_To, 7, 1, frequency);
devTEF_Set_Cmd(TEF_AM, Cmd_Tune_To, 4, 1, frequency);
}
void TEF6686::setOffset(int8_t offset) {
devTEF_Set_Cmd(TEF_FM, Cmd_Set_LevelOffset, 5, (offset * 10) - 70);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_LevelOffset, 2, (offset * 10) - 70);
}
void TEF6686::setAMOffset(int8_t offset) {
devTEF_Set_Cmd(TEF_AM, Cmd_Set_LevelOffset, 5, (offset * 10) - 70);
devTEF_Set_Cmd(TEF_AM, Cmd_Set_LevelOffset, 2, (offset * 10) - 70);
}
void TEF6686::setFMBandw(uint16_t bandwidth) {
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Bandwidth, 7, 0, bandwidth * 10);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Bandwidth, 4, 0, bandwidth * 10);
}
void TEF6686::setAMBandw(uint16_t bandwidth) {
devTEF_Set_Cmd(TEF_AM, Cmd_Set_Bandwidth, 7, 0, bandwidth * 10);
devTEF_Set_Cmd(TEF_AM, Cmd_Set_Bandwidth, 4, 0, bandwidth * 10);
}
void TEF6686::setAMCoChannel(uint16_t start, uint8_t level) {
uint8_t mode = 1;
if(start == 0) mode = 0;
devTEF_Set_Cmd(TEF_AM, Cmd_Set_CoChannelDet, 11, mode, 2, start * 10, 1000, level);
devTEF_Set_Cmd(TEF_AM, Cmd_Set_CoChannelDet, 8, mode, 2, start * 10, 1000, level);
}
void TEF6686::setSoftmuteAM(uint8_t mode) {
devTEF_Set_Cmd(TEF_AM, Cmd_Set_Softmute_Max, 7, mode, 250);
devTEF_Set_Cmd(TEF_AM, Cmd_Set_Softmute_Max, 4, mode, 250);
}
void TEF6686::setSoftmuteFM(uint8_t mode) {
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Softmute_Max, 7, mode, 200);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Softmute_Max, 4, mode, 200);
}
void TEF6686::setAMNoiseBlanker(uint16_t start) {
devTEF_Set_Cmd(TEF_AM, Cmd_Set_NoiseBlanker, 7, (start == 0) ? 0 : 1, (start == 0) ? 1000 : start * 10);
devTEF_Set_Cmd(TEF_AM, Cmd_Set_NoiseBlanker_Audio, 7, (start == 0) ? 0 : 1, 1000);
devTEF_Set_Cmd(TEF_AM, Cmd_Set_NoiseBlanker, 4, (start == 0) ? 0 : 1, (start == 0) ? 1000 : start * 10);
devTEF_Set_Cmd(TEF_AM, Cmd_Set_NoiseBlanker_Audio, 4, (start == 0) ? 0 : 1, 1000);
}
void TEF6686::setAMAttenuation(uint16_t start) {
devTEF_Set_Cmd(TEF_AM, Cmd_Set_Antenna, 5, start * 10);
devTEF_Set_Cmd(TEF_AM, Cmd_Set_Antenna, 2, start * 10);
}
void TEF6686::setFMABandw() {
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Bandwidth, 7, 1, 3110);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Bandwidth, 4, 1, 3110);
}
void TEF6686::setiMS(bool mph) {
devTEF_Set_Cmd(TEF_FM, Cmd_Set_MphSuppression, 5, mph);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_MphSuppression, 2, mph);
}
void TEF6686::setEQ(bool eq) {
devTEF_Set_Cmd(TEF_FM, Cmd_Set_ChannelEqualizer, 5, eq);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_ChannelEqualizer, 2, eq);
}
bool TEF6686::getStereoStatus() {
@@ -233,109 +232,109 @@ bool TEF6686::getStereoStatus() {
}
void TEF6686::setMono(bool mono) {
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Min, 7, mono ? 2 : 0);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Min, 4, mono ? 2 : 0);
}
void TEF6686::setVolume(int8_t volume) {
devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Volume, 5, volume * 10);
devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Volume, 2, volume * 10);
}
void TEF6686::setMute() {
mute = true;
if (mpxmode) devTEF_Set_Cmd(TEF_FM, Cmd_Set_Specials, 5, 0);
devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Mute, 5, 1);
if (mpxmode) devTEF_Set_Cmd(TEF_FM, Cmd_Set_Specials, 2, 0);
devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Mute, 2, 1);
}
void TEF6686::setUnMute() {
mute = false;
if (mpxmode) devTEF_Set_Cmd(TEF_FM, Cmd_Set_Specials, 5, 1);
devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Mute, 5, 0);
if (mpxmode) devTEF_Set_Cmd(TEF_FM, Cmd_Set_Specials, 2, 1);
devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Mute, 2, 0);
}
void TEF6686::setAGC(uint8_t agc) {
devTEF_Set_Cmd(TEF_FM, Cmd_Set_RFAGC, 7, agc * 10, 0);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_RFAGC, 4, agc * 10, 0);
}
void TEF6686::setAMAGC(uint8_t agc) {
devTEF_Set_Cmd(TEF_AM, Cmd_Set_RFAGC, 7, agc * 10, 0);
devTEF_Set_Cmd(TEF_AM, Cmd_Set_RFAGC, 4, agc * 10, 0);
}
void TEF6686::setDeemphasis(uint8_t timeconstant) {
switch (timeconstant) {
case 1: devTEF_Set_Cmd(TEF_FM, Cmd_Set_Deemphasis, 5, 500); break;
case 2: devTEF_Set_Cmd(TEF_FM, Cmd_Set_Deemphasis, 5, 750); break;
default: devTEF_Set_Cmd(TEF_FM, Cmd_Set_Deemphasis, 5, 0); break;
case 1: devTEF_Set_Cmd(TEF_FM, Cmd_Set_Deemphasis, 2, 500); break;
case 2: devTEF_Set_Cmd(TEF_FM, Cmd_Set_Deemphasis, 2, 750); break;
default: devTEF_Set_Cmd(TEF_FM, Cmd_Set_Deemphasis, 2, 0); break;
}
}
void TEF6686::setAudio(uint8_t audio) {
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Specials, 5, audio);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Specials, 2, audio);
mpxmode = (audio != 0);
}
void TEF6686::setFMSI(uint8_t mode) {
if(mode > 2) mode = 2;
if(mode < 1) mode = 1;
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StereoImprovement, 5, mode-1);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StereoImprovement, 2, mode-1);
}
void TEF6686::setFMSI_Time(uint16_t attack, uint16_t decay) {
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StBandBlend_Time, 7, attack, decay);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StBandBlend_Time, 4, attack, decay);
}
void TEF6686::setFMSI_Gain(uint16_t band1, uint16_t band2, uint16_t band3, uint16_t band4) {
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StBandBlend_Gain, 11, band1 * 10, band2 * 10, band3 * 10, band4 * 10);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StBandBlend_Gain, 8, band1 * 10, band2 * 10, band3 * 10, band4 * 10);
}
void TEF6686::setFMSI_Bias(int16_t band1, int16_t band2, int16_t band3, int16_t band4) {
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StBandBlend_Bias, 11, band1 - 250, band2 - 250, band3 - 250, band4 - 250);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StBandBlend_Bias, 8, band1 - 250, band2 - 250, band3 - 250, band4 - 250);
}
void TEF6686::setFMNoiseBlanker(uint16_t start) {
devTEF_Set_Cmd(TEF_FM, Cmd_Set_NoiseBlanker, 7, (start == 0) ? 0 : 1, (start == 0) ? 1000 : (start * 10));
devTEF_Set_Cmd(TEF_FM, Cmd_Set_NoiseBlanker, 4, (start == 0) ? 0 : 1, (start == 0) ? 1000 : (start * 10));
}
void TEF6686::setStereoLevel(uint8_t start) {
if (start == 0) {
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Level, 9, 0, start * 10, 60);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Noise, 9, 0, 240, 200);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Mph, 9, 0, 240, 200);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Level, 6, 0, start * 10, 60);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Noise, 6, 0, 240, 200);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Mph, 6, 0, 240, 200);
} else {
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Level, 9, 3, start * 10, 60);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Noise, 9, 3, 240, 200);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Mph, 9, 3, 240, 200);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Level, 6, 3, start * 10, 60);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Noise, 6, 3, 240, 200);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Mph, 6, 3, 240, 200);
}
}
void TEF6686::setHighCutOffset(uint8_t start) {
if (start == 0) {
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Level, 9, 0, start * 10, 300);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Noise, 9, 0, 360, 300);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Mph, 9, 0, 360, 300);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Level, 6, 0, start * 10, 300);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Noise, 6, 0, 360, 300);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Mph, 6, 0, 360, 300);
} else {
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Level, 9, 3, start * 10, 300);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Noise, 9, 3, 360, 300);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Mph, 9, 3, 360, 300);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Level, 6, 3, start * 10, 300);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Noise, 6, 3, 360, 300);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Mph, 6, 3, 360, 300);
}
}
void TEF6686::setHighCutLevel(uint16_t limit) {
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Max, 7, 1, limit * 100);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Max, 4, 1, limit * 100);
}
void TEF6686::setStHiBlendLevel(uint16_t limit) {
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Max, 7, 1, limit * 100);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Max, 4, 1, limit * 100);
}
void TEF6686::setStHiBlendOffset(uint8_t start) {
if (start == 0) {
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Level, 9, 0, start * 10, 300);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Noise, 9, 0, 360, 300);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Mph, 9, 0, 360, 300);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Level, 6, 0, start * 10, 300);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Noise, 6, 0, 360, 300);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Mph, 6, 0, 360, 300);
} else {
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Level, 9, 3, start * 10, 300);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Noise, 9, 3, 360, 300);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Mph, 9, 3, 360, 300);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Level, 6, 3, start * 10, 300);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Noise, 6, 3, 360, 300);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Mph, 6, 3, 360, 300);
}
}
@@ -360,23 +359,19 @@ void TEF6686::getStatusAM(int16_t *level, uint16_t *noise, uint16_t *cochannel,
void TEF6686::readRDS(byte showrdserrors) {
if(rds.filter && ps_process) devTEF_Radio_Get_RDS_Status(&rds.rdsStat, &rds.rdsA, &rds.rdsB, &rds.rdsC, &rds.rdsD, &rds.rdsErr);
else {
if(millis() >= rdstimer + 87) {
rdstimer += 87;
for(int i = 0; i < 3; i++) {
devTEF_Radio_Get_RDS_Data(&rds.rdsStat, &rds.rdsA, &rds.rdsB, &rds.rdsC, &rds.rdsD, &rds.rdsErr);
if(bitRead(rds.rdsStat, 14)) {
for (int i = 0; i < 22; i++) devTEF_Radio_Get_RDS_Data(&rds.rdsStat, &rds.rdsA, &rds.rdsB, &rds.rdsC, &rds.rdsD, &rds.rdsErr);
}
delay(2);
if(bitRead(rds.rdsStat, 15)) break;
}
}
if(bitRead(rds.rdsStat, 9)) {
rds.hasRDS = true;
bitStartTime = 0;
dropped_groups = 0;
} else {
if(bitStartTime == 0) bitStartTime = millis();
else if(millis() - bitStartTime >= 87) rds.hasRDS = false;
if(dropped_groups > 7) rds.hasRDS = false;
dropped_groups++;
return; // No sync means no data, ever! Unless sync status changes of course
}
@@ -1215,18 +1210,18 @@ void TEF6686::readRDS(byte showrdserrors) {
if (rds.rdsD == 0x4BD7) {
rds.hasRTplus = true;
rtplusblock = ((rds.rdsB & 0x1F) >> 1) * 2;
rtplusblock = rds.rdsB & 0x1E;
}
if (rds.rdsD == 0x0093) {
rds.hasDABAF = true;
DABAFblock = ((rds.rdsB & 0x1F) >> 1) * 2;
DABAFblock = rds.rdsB & 0x1E;
}
if (rds.rdsD == 0x6552) {
_hasEnhancedRT = true;
eRTblock = ((rds.rdsB & 0x1F) >> 1) * 2;
eRTcoding = bitRead(rds.rdsC, 0);
eRTblock = rds.rdsB & 0x1E;
eRTcoding = rds.rdsC & 1;
}
}
} break;
@@ -1250,11 +1245,11 @@ void TEF6686::readRDS(byte showrdserrors) {
if ((M + 2 - (12 * J)) < 13) month = M + 2 - (12 * J);
if ((100 * (C - 49) + Y + J) > 2022) year = 100 * (C - 49) + Y + J;
hour = ((rds.rdsD >> 12) & 0xf) | ((rds.rdsC << 4) & 0x10);
timeoffset = rds.rdsD & 0x001f;
hour = ((rds.rdsD >> 12) & 0xF) | ((rds.rdsC << 4) & 0x10);
timeoffset = rds.rdsD & 0x1F;
if (bitRead(rds.rdsD, 5)) timeoffset *= -1;
timeoffset *= 1800;
minute = (rds.rdsD & 0x0fc0) >> 6;
minute = (rds.rdsD & 0xFC0) >> 6;
if (year < 2026 || hour > 23 || minute > 59 || timeoffset > 55800 || timeoffset < -55800) break;
@@ -1279,8 +1274,7 @@ void TEF6686::readRDS(byte showrdserrors) {
if (!NTPupdated) {
time_t corrected_time = rds_utc_time - (current_correction / 2);
rtc.setTime(corrected_time);
sync_to_rx_rtc();
set_time(corrected_time);
}
} else rds.hasCT = false;
lastrdstime = rdstime;
@@ -1562,7 +1556,7 @@ void TEF6686::readRDS(byte showrdserrors) {
}
void TEF6686::clearRDS(bool fullsearchrds) {
devTEF_Set_Cmd(TEF_FM, Cmd_Set_RDS, 9, fullsearchrds ? 3 : 1, 1, 0);
devTEF_Set_Cmd(TEF_FM, Cmd_Set_RDS, 6, fullsearchrds ? 3 : 1, 1, 0);
rds.piBuffer.clear();
rds.stationName = rds.stationText = rds.stationNameLong = "";
rds.PTYN = rds.stationText32 = rds.RTContent1 = rds.RTContent2 = "";;
@@ -1648,7 +1642,7 @@ void TEF6686::clearRDS(bool fullsearchrds) {
}
void TEF6686::tone(uint16_t time, int16_t amplitude, uint16_t frequency) {
devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Mute, 5, 0);
devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Mute, 2, 0);
devTEF_Radio_Set_Wavegen(1, amplitude, frequency);
delay(time);
devTEF_Radio_Set_Wavegen(0, 0, 0);
@@ -1697,10 +1691,10 @@ void TEF6686::RDScharConverter(const char* input, wchar_t* output, size_t size,
case 0x9B: output[i] = L'ç'; break;
case 0x9C: output[i] = L'ş'; break;
case 0x9D: output[i] = L'ǧ'; break;
case 0x9E: output[i] = L'ı'; break;
case 0x9E: output[i] = L'\x131'; break;
case 0x9F: output[i] = L'ij'; break;
case 0xA0: output[i] = L'ª'; break;
case 0xA1: output[i] = L'α'; break;
case 0xA1: output[i] = L'\x3b1'; break;
case 0xA2: output[i] = L'©'; break;
case 0xA3: output[i] = L'‰'; break;
case 0xA4: output[i] = L'Ǧ'; break;

48
src/Tuner_Drv_Lithio.cpp
View File

@@ -10,14 +10,14 @@ void devTEF_Set_Cmd(TEF_MODULE module, uint8_t cmd, uint16_t len, ...) {
buf[1] = cmd;
buf[2] = 1;
for (i = 3; i < len; i++) {
for (i = 0; i < len; i++) {
temp = va_arg(vArgs, int);
buf[i++] = High_16bto8b(temp);
buf[i] = Low_16bto8b(temp);
buf[3 + i++] = High_16bto8b(temp);
buf[3 + i] = Low_16bto8b(temp);
}
va_end(vArgs);
Tuner_WriteBuffer(buf, len);
Tuner_WriteBuffer(buf, len + 3);
}
bool devTEF_Get_Cmd(TEF_MODULE module, uint8_t cmd, uint8_t *receive, uint16_t len) {
@@ -32,25 +32,10 @@ bool devTEF_Get_Cmd(TEF_MODULE module, uint8_t cmd, uint8_t *receive, uint16_t l
uint8_t devTEF_APPL_Get_Operation_Status() {
uint8_t buf[2];
while(!devTEF_Get_Cmd(TEF_APPL, Cmd_Get_Operation_Status, buf, sizeof(buf))) delay(1);
while(!devTEF_Get_Cmd(TEF_APPL, Cmd_Get_Operation_Status, buf, sizeof(buf))) delay(2);
return Convert8bto16b(buf);
}
bool devTEF_Radio_Get_Processing_Status(uint16_t *highcut, uint16_t *stereo, uint16_t *sthiblend, uint8_t *stband_1, uint8_t *stband_2, uint8_t *stband_3, uint8_t *stband_4) {
uint8_t buf[12];
uint16_t r = devTEF_Get_Cmd(TEF_FM, Cmd_Get_Processing_Status, buf, sizeof(buf));
*highcut = Convert8bto16b(buf + 2) / 10;
*stereo = Convert8bto16b(buf + 4) / 10;
*sthiblend = Convert8bto16b(buf + 6) / 10;
uint16_t stband_1_2 = Convert8bto16b(buf + 8);
uint16_t stband_3_4 = Convert8bto16b(buf + 10);
*stband_1 = High_16bto8b(stband_1_2);
*stband_2 = Low_16bto8b(stband_1_2);
*stband_3 = High_16bto8b(stband_3_4);
*stband_4 = Low_16bto8b(stband_3_4);
return r;
}
void devTEF_Radio_Get_Quality_Status(uint16_t *status, int16_t *level, uint16_t *usn, uint16_t *wam, int16_t *offset, uint16_t *bandwidth, uint16_t *mod, int8_t *snr) {
uint8_t buf[14];
devTEF_Get_Cmd(TEF_FM, Cmd_Get_Quality_Data, buf, sizeof(buf));
@@ -77,16 +62,15 @@ void devTEF_Radio_Get_RDS_Status(uint16_t *status, uint16_t *A_block, uint16_t *
if(dec_error != NULL) *dec_error = Convert8bto16b(buf + 10);
}
bool devTEF_Radio_Get_RDS_Data(uint16_t *status, uint16_t *A_block, uint16_t *B_block, uint16_t *C_block, uint16_t *D_block, uint16_t *dec_error) {
void devTEF_Radio_Get_RDS_Data(uint16_t *status, uint16_t *A_block, uint16_t *B_block, uint16_t *C_block, uint16_t *D_block, uint16_t *dec_error) {
uint8_t buf[12];
uint8_t r = devTEF_Get_Cmd(TEF_FM, Cmd_Get_RDS_Data, buf, sizeof(buf));
*status = Convert8bto16b(buf);
*A_block = Convert8bto16b(buf + 2);
*B_block = Convert8bto16b(buf + 4);
*C_block = Convert8bto16b(buf + 6);
*D_block = Convert8bto16b(buf + 8);
*dec_error = Convert8bto16b(buf + 10);
return r;
devTEF_Get_Cmd(TEF_FM, Cmd_Get_RDS_Data, buf, sizeof(buf));
if(status != NULL) *status = Convert8bto16b(buf);
if(A_block != NULL) *A_block = Convert8bto16b(buf + 2);
if(B_block != NULL) *B_block = Convert8bto16b(buf + 4);
if(C_block != NULL) *C_block = Convert8bto16b(buf + 6);
if(D_block != NULL) *D_block = Convert8bto16b(buf + 8);
if(dec_error != NULL) *dec_error = Convert8bto16b(buf + 10);
}
bool devTEF_Radio_Get_Stereo_Status(uint16_t *status) {
@@ -98,7 +82,7 @@ bool devTEF_Radio_Get_Stereo_Status(uint16_t *status) {
}
void devTEF_Radio_Set_Wavegen(bool mode, int16_t amplitude, uint16_t freq) {
devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Input, 5, mode ? 240 : 0);
if (mode) devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_WaveGen, 15, 5, 0, amplitude * 10, freq, amplitude * 10, freq);
else devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_WaveGen, 15, 0);
devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Input, 2, mode ? 240 : 0);
if (mode) devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_WaveGen, 12, 5, 0, amplitude * 10, freq, amplitude * 10, freq);
else devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_WaveGen, 12, 0);
}

2
src/Tuner_Interface.cpp
View File

@@ -9,7 +9,7 @@ bool Tuner_WriteBuffer(unsigned char *buf, uint16_t len) {
Wire.beginTransmission(TEF668X_ADDRESS);
for (uint16_t i = 0; i < len; i++) Wire.write(buf[i]);
uint8_t r = Wire.endTransmission();
if (!Data_Accelerator) delay(1);
if (!Data_Accelerator) delay(2);
return (r == 0) ? true : false;
}

2
src/logbook.cpp
View File

@@ -406,9 +406,11 @@ void sendUDPlog() {
String CHIP = "";
switch (chipmodel) {
case 0: CHIP = "TEF6686"; break;
#ifndef DEEPELEC_DP_66X
case 1: CHIP = "TEF6687"; break;
case 2: CHIP = "TEF6688"; break;
case 3: CHIP = "TEF6689"; break;
#endif
}
String RTPLUS = "";

77
src/main.cpp
View File

@@ -4,7 +4,6 @@
#include <Wire.h>
#include <Hash.h>
#include <FS.h>
#include <TimeLib.h>
using fs::FS;
#include <SPIFFS.h>
#include "NTPupdate.h"
@@ -252,7 +251,7 @@ void SetTunerPatch() {
EEPROM.writeByte(EE_BYTE_TEF, TEF);
EEPROM.commit();
Tuner_Reset();
ESP.restart();
esp_restart();
}
}
@@ -1159,11 +1158,12 @@ void setup() {
Wire.begin();
Wire.setClock(400000);
delay(5);
delay(3);
Serial.begin(115200);
Serial.println();
byte error, address;
for (address = 1; address < 127; address++) {
for (address = 1; address < 108; address++) {
Wire.beginTransmission(address);
error = Wire.endTransmission();
@@ -1175,6 +1175,8 @@ void setup() {
Serial.print(" RTC");
rx_rtc_avail = true;
}
else if(address == TEF668X_ADDRESS) Serial.print(" TEF");
else if(address == XL9555_ADDRESS) Serial.print(" GPIO");
Serial.println(" !");
} else if (error == 4) {
Serial.print("Unknown error at 0x");
@@ -1182,21 +1184,19 @@ void setup() {
Serial.println(address, HEX);
}
}
Serial.flush();
Serial.end();
rtc.setTime(0);
if(rx_rtc_avail) {
RX8010SJ::DateTime defaulttime = RX8010SJ::DateTime();
defaulttime.second = 21;
defaulttime.minute = 45;
defaulttime.hour = 11;
defaulttime.dayOfWeek = 6;
defaulttime.dayOfMonth = 11;
defaulttime.month = 1;
defaulttime.year = 26;
bool reset = rx_rtc.initModule(); // initModule, not initAdapter, adapter also reinits wire
if(reset) {
RX8010SJ::DateTime defaulttime = RX8010SJ::DateTime();
defaulttime.second = 00;
defaulttime.minute = 00;
defaulttime.hour = 18;
defaulttime.dayOfWeek = 1;
defaulttime.dayOfMonth = 13;
defaulttime.month = 1;
defaulttime.year = 26;
Serial.println("RTC reset with defaults");
rx_rtc.writeDateTime(defaulttime);
} else {
@@ -1205,6 +1205,9 @@ void setup() {
}
}
Serial.flush();
Serial.end();
EEPROM.begin(EE_TOTAL_CNT);
loadData();
@@ -1408,7 +1411,7 @@ void setup() {
Infoboxprint(textUI(66));
tftPrint(ACENTER, textUI(2), 155, 130, ActiveColor, ActiveColorSmooth, 28);
while (digitalRead(ROTARY_BUTTON) == LOW && digitalRead(BWBUTTON) == LOW) delay(50);
ESP.restart();
esp_restart();
}
if (digitalRead(BWBUTTON) == LOW && digitalRead(ROTARY_BUTTON) == HIGH && digitalRead(MODEBUTTON) == LOW && digitalRead(BANDBUTTON) == HIGH) {
@@ -1439,7 +1442,7 @@ void setup() {
tft.fillScreen(BackgroundColor);
tftPrint(ACENTER, textUI(8), 160, 3, PrimaryColor, PrimaryColorSmooth, 28);
tftPrint(ACENTER, "Software " + String(VERSION), 160, 152, PrimaryColor, PrimaryColorSmooth, 16);
tftPrint(ACENTER, "Firmware " + String(VERSION), 160, 152, PrimaryColor, PrimaryColorSmooth, 16);
tft.fillRect(120, 230, 16, 6, GreyoutColor);
tft.fillRect(152, 230, 16, 6, GreyoutColor);
@@ -1492,7 +1495,7 @@ void setup() {
tft.fillRect(152, 230, 16, 6, SignificantColor);
while (true);
}
tftPrint(ACENTER, "Patch: v" + String(TEF), 160, 202, ActiveColor, ActiveColorSmooth, 28);
tftPrint(ACENTER, "Patch: v" + String(TEF) + " HW " + String(hw >> 8) + "." + String(hw & 0xff) + " SW " + String(sw >> 8) + "." + String(sw & 0xff), 160, 202, ActiveColor, ActiveColorSmooth, 16);
// Configures the GPIO chip for input in every pin
Wire.beginTransmission(XL9555_ADDRESS);
@@ -1507,14 +1510,14 @@ void setup() {
if (wifi) {
tryWiFi();
tft.fillRect(184, 230, 16, 6, PrimaryColor);
delay(2000);
delay(1750);
} else {
Server.end();
Udp.stop();
tft.fillRect(184, 230, 16, 6, SignificantColor);
}
while(digitalRead(ROTARY_BUTTON) == LOW) delay(50);
while(digitalRead(ROTARY_BUTTON) == LOW) delay(75);
radio.setVolume(VolSet);
radio.setOffset(LevelOffset);
@@ -2035,7 +2038,6 @@ void DivdeSWMIBand() {
}
SWMIBandPos = SW_MI_BAND_GAP;
}
}
void ToggleSWMIBand(bool frequencyup) {
@@ -4044,4 +4046,39 @@ uint8_t doAutoMemory(uint16_t startfreq, uint16_t stopfreq, uint8_t startmem, ui
SQ = false;
return error;
}
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_task_wdt.h"
#ifndef ARDUINO_LOOP_STACK_SIZE
#ifndef CONFIG_ARDUINO_LOOP_STACK_SIZE
#define ARDUINO_LOOP_STACK_SIZE 8192
#else
#define ARDUINO_LOOP_STACK_SIZE CONFIG_ARDUINO_LOOP_STACK_SIZE
#endif
#endif
TaskHandle_t loopTaskHandle = NULL;
bool loopTaskWDTEnabled;
__attribute__((weak)) size_t getArduinoLoopTaskStackSize(void) {
return ARDUINO_LOOP_STACK_SIZE;
}
void loopTask(void *pvParameters)
{
setup();
for(;;) {
if(loopTaskWDTEnabled) esp_task_wdt_reset();
loop();
if (serialEventRun) serialEventRun();
}
}
extern "C" void app_main() {
initArduino();
xTaskCreateUniversal(loopTask, "loopTask", getArduinoLoopTaskStackSize(), NULL, 1, &loopTaskHandle, ARDUINO_RUNNING_CORE);
}

7
src/rds.cpp
View File

@@ -1,6 +1,5 @@
#include "rds.h"
#include "constants.h"
#include <TimeLib.h>
#include "utils.h"
String HexStringold;
@@ -513,7 +512,7 @@ void showPS() {
}
void showCT() {
char timeStr[16];
char timeStr[32];
char dateStr[9];
time_t t = rtc.getEpoch();
@@ -532,8 +531,8 @@ void showCT() {
else if (hour > 12) hour -= 12;
}
String ampm = (localtm->tm_hour >= 12) ? "PM" : "AM";
snprintf(timeStr, sizeof(timeStr), "%d:%02d %s", hour, localtm->tm_min, ampm.c_str());
const char* ampm = (localtm->tm_hour >= 12) ? "PM" : "AM";
snprintf(timeStr, sizeof(timeStr), "%d:%02d %.2s", hour, localtm->tm_min, ampm);
} else {
int hour = localtm->tm_hour;
if (hour < 0 || hour > 23) hour = 0;

35
src/rtc.cpp
View File

@@ -14,23 +14,8 @@ void timeToDateTime(time_t t, struct RX8010SJ::DateTime* dateTime) {
dateTime->hour = timeinfo->tm_hour;
dateTime->dayOfWeek = (timeinfo->tm_wday + 6) % 7;
dateTime->dayOfMonth = timeinfo->tm_mday;
dateTime->month = timeinfo->tm_mon + 1; // tm_mon is 0-11, convert to 1-12
dateTime->year = (timeinfo->tm_year + 1900) % 100; // Get last 2 digits
}
time_t timegm(struct tm *tm) {
// https://linux.die.net/man/3/timegm
time_t ret;
char *tz;
tz = getenv("TZ");
setenv("TZ", "", 1);
tzset();
ret = mktime(tm);
if (tz) setenv("TZ", tz, 1);
else unsetenv("TZ");
tzset();
return ret;
dateTime->month = timeinfo->tm_mon + 1;
dateTime->year = (timeinfo->tm_year + 1900) % 100;
}
time_t dateTimeToTime(const struct RX8010SJ::DateTime* dateTime) {
@@ -42,17 +27,19 @@ time_t dateTimeToTime(const struct RX8010SJ::DateTime* dateTime) {
timeinfo.tm_mon = dateTime->month - 1;
timeinfo.tm_year = dateTime->year + 100;
timeinfo.tm_isdst = 0;
return timegm(&timeinfo);
return mktime(&timeinfo);
}
void sync_to_rx_rtc(int32_t offset) {
if(!rx_rtc_avail) return;
RX8010SJ::DateTime rx_currenttime = RX8010SJ::DateTime();
timeToDateTime(rtc.getEpoch() + offset, &rx_currenttime);
rx_rtc.writeDateTime(rx_currenttime);
}
void sync_from_rx_rtc(int32_t offset) {
if(!rx_rtc_avail) return;
RX8010SJ::DateTime dateTime = rx_rtc.readDateTime();
rtc.setTime(dateTimeToTime(&dateTime) + offset);
}
void set_time(time_t time) {
rtc.setTime(time);
if(!rx_rtc_avail) return;
RX8010SJ::DateTime rx_currenttime = RX8010SJ::DateTime();
timeToDateTime(time, &rx_currenttime);
rx_rtc.writeDateTime(rx_currenttime);
}