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

API update, stepsize update and RDS fix

Browse Source 
Updated API.
Added stepsize 10MHz (FM) / 1MHz (AM)
Make RDS more sensitive.
This commit is contained in:
Sjef Verhoeven PE5PVB
2023-06-02 23:09:17 +02:00
parent e2791cc24c
commit 825cc68339
11 changed files with 808 additions and 637 deletions
Download Patch File Download Diff File Expand all files Collapse all files

296
TEF6686_ESP32.ino
View File

@@ -373,18 +373,10 @@ void setup() {
btStop();
Serial.begin(115200);
if (iMSset == 1 && EQset == 1) {
iMSEQ = 2;
}
if (iMSset == 0 && EQset == 1) {
iMSEQ = 3;
}
if (iMSset == 1 && EQset == 0) {
iMSEQ = 4;
}
if (iMSset == 0 && EQset == 0) {
iMSEQ = 1;
}
if (iMSset == 1 && EQset == 1) iMSEQ = 2;
if (iMSset == 0 && EQset == 1) iMSEQ = 3;
if (iMSset == 1 && EQset == 0) iMSEQ = 4;
if (iMSset == 0 && EQset == 0) iMSEQ = 1;
tft.init();
@@ -598,49 +590,32 @@ void loop() {
if (millis() >= lowsignaltimer + 300) {
lowsignaltimer = millis();
if (band == 0) radio.getStatus(SStatus, USN, WAM, OStatus, BW, MStatus); else radio.getStatus_AM(SStatus, USN, WAM, OStatus, BW, MStatus);
if (band == 0) radio.getStatus(SStatus, USN, WAM, OStatus, BW, MStatus); else radio.getStatusAM(SStatus, USN, WAM, OStatus, BW, MStatus);
if (screenmute == true) readRds();
if (menu == false) doSquelch();
if (menu == false) {
doSquelch();
GetData();
}
}
} else {
if (band == 0) radio.getStatus(SStatus, USN, WAM, OStatus, BW, MStatus); else radio.getStatus_AM(SStatus, USN, WAM, OStatus, BW, MStatus);
if (band == 0) radio.getStatus(SStatus, USN, WAM, OStatus, BW, MStatus); else radio.getStatusAM(SStatus, USN, WAM, OStatus, BW, MStatus);
if (menu == false) {
doSquelch();
readRds();
if (screenmute == false) {
ShowModLevel();
}
}
}
if (menu == false) {
if (screenmute == false) {
if (band == 0) {
showPI();
showPTY();
showCT();
showPS();
showRadioText();
showPS();
ShowStereoStatus();
}
ShowOffset();
ShowSignalLevel();
ShowBW();
GetData();
if (screenmute == false) ShowModLevel();
}
}
XDRGTKRoutine();
if (menu == true && menuopen == true && menuoption == 110)
{
if (band == 0) radio.getStatus(SStatus, USN, WAM, OStatus, BW, MStatus); else radio.getStatus_AM(SStatus, USN, WAM, OStatus, BW, MStatus);
if (menu == true && menuopen == true && menuoption == 110) {
if (band == 0) radio.getStatus(SStatus, USN, WAM, OStatus, BW, MStatus); else radio.getStatusAM(SStatus, USN, WAM, OStatus, BW, MStatus);
if (millis() >= lowsignaltimer + 500 || change2 == true) {
lowsignaltimer = millis();
change2 = false;
if (SStatus > SStatusold || SStatus < SStatusold)
{
if (SStatus > SStatusold || SStatus < SStatusold) {
String count = String(SStatus / 10, DEC);
if (screenmute == false) {
tft.setTextColor(TFT_BLACK);
@@ -656,8 +631,7 @@ void loop() {
tft.setTextFont(6);
tft.print(SStatusold / 10);
tft.print(".");
if (SStatusold < 0)
{
if (SStatusold < 0) {
String negative = String (SStatusold % 10, DEC);
if (SStatusold % 10 == 0) tft.print("0"); else tft.print(negative[1]);
} else {
@@ -677,8 +651,7 @@ void loop() {
tft.setTextFont(6);
tft.print(SStatus / 10);
tft.print(".");
if (SStatus < 0)
{
if (SStatus < 0) {
String negative = String (SStatus % 10, DEC);
if (SStatus % 10 == 0) tft.print("0"); else tft.print(negative[1]);
} else {
@@ -703,8 +676,8 @@ void loop() {
if (change > 200 && store == true) {
detachInterrupt(digitalPinToInterrupt(ROTARY_PIN_A));
detachInterrupt(digitalPinToInterrupt(ROTARY_PIN_B));
EEPROM.writeUInt(0, radio.getFrequency());
EEPROM.writeUInt(47, radio.getFrequency_AM());
EEPROM.writeUInt(0, frequency);
EEPROM.writeUInt(47, frequency_AM);
EEPROM.writeByte(46, band);
EEPROM.commit();
store = false;
@@ -714,6 +687,23 @@ void loop() {
}
}
void GetData() {
if (screenmute == false) {
if (band == 0) {
showPI();
showPTY();
showCT();
showPS();
showRadioText();
showPS();
ShowStereoStatus();
}
ShowOffset();
ShowSignalLevel();
ShowBW();
}
}
void PWRButtonPress() {
if (menu == false) {
unsigned long counterold = millis();
@@ -747,8 +737,8 @@ void PWRButtonPress() {
}
void StoreFrequency() {
EEPROM.writeUInt(0, radio.getFrequency());
EEPROM.writeUInt(47, radio.getFrequency_AM());
EEPROM.writeUInt(0, frequency);
EEPROM.writeUInt(47, frequency_AM);
EEPROM.writeByte(46, band);
EEPROM.commit();
}
@@ -759,11 +749,10 @@ void SelectBand() {
tunemode = false;
BWreset = true;
BWset = 2;
if (radio.getFrequency_AM() > 0) frequency_AM = radio.getFrequency_AM();
radio.setFrequency_AM(frequency_AM);
radio.SetFreqAM(frequency_AM);
freqold = frequency_AM;
doBW;
radio.getStatus_AM(SStatus, USN, WAM, OStatus, BW, MStatus);
radio.getStatusAM(SStatus, USN, WAM, OStatus, BW, MStatus);
if (screenmute == false) BuildDisplay();
tft.drawString("PI:", 216, 195, 2);
tft.drawString("PS:", 6, 195, 2);
@@ -781,7 +770,7 @@ void SelectBand() {
BWset = 0;
radio.power(0);
delay(50);
radio.setFrequency(frequency, LowEdgeSet, HighEdgeSet, fullsearchrds);
radio.SetFreq(frequency);
freqold = frequency_AM;
doBW;
radio.getStatus(SStatus, USN, WAM, OStatus, BW, MStatus);
@@ -803,6 +792,7 @@ void BWButtonPress() {
doStereoToggle();
}
}
while (digitalRead(BWBUTTON) == LOW) delay(50);
delay(100);
}
@@ -892,32 +882,39 @@ void ShowStepSize() {
tft.fillRect(224, 38, 15, 4, TFT_GREYOUT);
tft.fillRect(193, 38, 15, 4, TFT_GREYOUT);
if (band == 0) tft.fillRect(148, 38, 15, 4, TFT_GREYOUT); else tft.fillRect(162, 38, 15, 4, TFT_GREYOUT);
if (band == 0) tft.fillRect(116, 38, 15, 4, TFT_GREYOUT); else tft.fillRect(128, 38, 15, 4, TFT_GREYOUT);
if (stepsize == 1) tft.fillRect(224, 38, 15, 4, TFT_GREEN);
if (stepsize == 2) tft.fillRect(193, 38, 15, 4, TFT_GREEN);
if (stepsize == 3) {
if (band == 0) tft.fillRect(148, 38, 15, 4, TFT_GREEN); else tft.fillRect(162, 38, 15, 4, TFT_GREEN);
}
if (stepsize == 4) {
if (band == 0) tft.fillRect(116, 38, 15, 4, TFT_GREEN); else tft.fillRect(128, 38, 15, 4, TFT_GREEN);
}
}
void RoundStep() {
if (band == 0) {
int freq = radio.getFrequency();
unsigned int freq = frequency;
if (freq % 10 < 3) {
radio.setFrequency(freq - (freq % 10 - 5) - 5, LowEdgeSet, HighEdgeSet, fullsearchrds);
frequency = (freq - freq % 10);
}
else if (freq % 10 > 2 && freq % 10 < 8) {
radio.setFrequency(freq - (freq % 10 - 5) , LowEdgeSet, HighEdgeSet, fullsearchrds);
frequency = (freq - (freq % 10 - 5));
}
else if (freq % 10 > 7) {
radio.setFrequency(freq - (freq % 10 - 5) + 5, LowEdgeSet, HighEdgeSet, fullsearchrds);
frequency = (freq - (freq % 10) + 10);
}
} else {
int freq = radio.getFrequency_AM();
if (freq < 2000) radio.setFrequency_AM((freq / 9) * 9); else radio.setFrequency_AM((freq / 5) * 5);
radio.SetFreq(frequency);
}
if (band == 1) {
unsigned int freq = frequency_AM / 9;
frequency_AM = freq * 9;
radio.SetFreqAM(frequency_AM);
}
while (digitalRead(ROTARY_BUTTON) == LOW) delay(50);
if (band == 0) EEPROM.writeUInt(0, radio.getFrequency()); else EEPROM.writeUInt(47, radio.getFrequency_AM());
if (band == 0) EEPROM.writeUInt(0, frequency); else EEPROM.writeUInt(47, frequency_AM);
EEPROM.commit();
}
@@ -931,7 +928,7 @@ void ButtonPress() {
if (counter - counterold < 1000) {
if (tunemode == false) {
stepsize++;
if (stepsize > 3) stepsize = 0;
if (stepsize > 4) stepsize = 0;
if (screenmute == false) ShowStepSize();
@@ -1084,7 +1081,7 @@ void KeyUp() {
seek = true;
Seek(direction);
} else {
if (band == 0) frequency = radio.tuneUp(stepsize, LowEdgeSet, HighEdgeSet, fullsearchrds); else frequency_AM = radio.tuneUp_AM(stepsize);
TuneUp();
}
if (USBstatus == true) if (band == 0) Serial.println("T" + String(frequency * 10)); else Serial.println("T" + String(frequency_AM));
radio.clearRDS(fullsearchrds);
@@ -1223,7 +1220,7 @@ void KeyDown() {
seek = true;
Seek(direction);
} else {
if (band == 0) frequency = radio.tuneDown(stepsize, LowEdgeSet, HighEdgeSet, fullsearchrds); else frequency_AM = radio.tuneDown_AM(stepsize);
TuneDown();
}
if (USBstatus == true) if (band == 0) Serial.println("T" + String(frequency * 10)); else Serial.println("T" + String(frequency_AM));
radio.clearRDS(fullsearchrds);
@@ -1358,8 +1355,6 @@ void KeyDown() {
}
}
void readRds() {
if (band == 0) {
RDSstatus = radio.readRDS();
@@ -1387,6 +1382,7 @@ void readRds() {
Serial.print ("P");
Serial.print (String(((radio.rds.rdsA >> 8) >> 4) & 0xF, HEX) + String((radio.rds.rdsA >> 8) & 0xF, HEX));
Serial.print (String(((radio.rds.rdsA) >> 4) & 0xF, HEX) + String((radio.rds.rdsA) & 0xF, HEX));
if (radio.rds.correct == false) Serial.print("?");
Serial.print ("\n");
XDRGTKRDS = "R";
@@ -1632,8 +1628,8 @@ void BuildDisplay() {
void ShowFreq(int mode) {
if (setupmode == false) {
if (band == 1) {
if (freqold < 2000 && radio.getFrequency_AM() >= 2000 && stepsize == 0) if (radio.getFrequency_AM() != 27000 && freqold != 144) radio.setFrequency_AM(2000);
if (freqold >= 2000 && radio.getFrequency_AM() < 2000 && stepsize == 0) if (radio.getFrequency_AM() != 144 && freqold != 27000) radio.setFrequency_AM(1998);
if (freqold < 2000 && frequency_AM >= 2000 && stepsize == 0) if (frequency_AM != 27000 && freqold != 144) radio.SetFreqAM(2000);
if (freqold >= 2000 && frequency_AM < 2000 && stepsize == 0) if (frequency_AM != 144 && freqold != 27000) radio.SetFreqAM(1998);
}
}
@@ -1641,7 +1637,7 @@ void ShowFreq(int mode) {
detachInterrupt(digitalPinToInterrupt(ROTARY_PIN_A));
detachInterrupt(digitalPinToInterrupt(ROTARY_PIN_B));
if (band == 1) {
unsigned int freq = radio.getFrequency_AM();
unsigned int freq = frequency_AM;
String count = String(freq, DEC);
if (count.length() != freqoldcount || mode != 0) {
tft.setTextColor(TFT_BLACK);
@@ -1652,7 +1648,7 @@ void ShowFreq(int mode) {
freqold = freq;
freqoldcount = count.length();
} else {
unsigned int freq = radio.getFrequency() + ConverterSet * 100;
unsigned int freq = frequency + ConverterSet * 100;
String count = String(freq / 100, DEC);
if (count.length() != freqoldcount || mode != 0) {
tft.setTextColor(TFT_BLACK);
@@ -1661,9 +1657,11 @@ void ShowFreq(int mode) {
if (freqoldcount >= 4) tft.setCursor (44, 45);
tft.setTextFont(7);
tft.print(freqold / 100);
tft.print(".");
if (freqold % 100 < 10) tft.print("0");
tft.print(freqold % 100);
if (band == 0) {
tft.print(".");
if (freqold % 100 < 10) tft.print("0");
tft.print(freqold % 100);
}
}
tft.setTextColor(TFT_YELLOW, TFT_BLACK);
@@ -1721,10 +1719,8 @@ void ShowSignalLevel() {
int16_t smeter = 0;
int16_t segments;
if (SStatus > 0)
{
if (SStatus < 1000)
{
if (SStatus > 0) {
if (SStatus < 1000) {
sval = 51 * ((pow(10, (((float)SStatus) / 1000))) - 1);
smeter = int16_t(sval);
} else {
@@ -1738,8 +1734,7 @@ void ShowSignalLevel() {
if (menu == false) analogWrite(SMETERPIN, smeter);
if (SStatus > (SStatusold + 3) || SStatus < (SStatusold - 3))
{
if (SStatus > (SStatusold + 3) || SStatus < (SStatusold - 3)) {
if (SStatus > 1200) SStatus = 1200;
if (SStatus < -400) SStatus = -400;
String count = String(abs(SStatus / 10), DEC);
@@ -1759,8 +1754,7 @@ void ShowSignalLevel() {
tft.setCursor (294, 110);
tft.setTextFont(4);
tft.print(".");
if (SStatus < 0)
{
if (SStatus < 0) {
String negative = String (SStatus % 10, DEC);
if (SStatus % 10 == 0) tft.print("0"); else tft.print(negative[1]);
} else {
@@ -1780,8 +1774,7 @@ void ShowSignalLevel() {
void ShowRDSLogo(bool RDSstatus) {
if (screenmute == false) {
if (RDSstatus != RDSstatusold)
{
if (RDSstatus != RDSstatusold) {
if (RDSstatus == true) tft.drawBitmap(110, 5, RDSLogo, 67, 22, TFT_SKYBLUE); else tft.drawBitmap(110, 5, RDSLogo, 67, 22, TFT_GREYOUT);
RDSstatusold = RDSstatus;
}
@@ -1789,13 +1782,10 @@ void ShowRDSLogo(bool RDSstatus) {
}
void ShowStereoStatus() {
if (StereoToggle == true)
{
if (StereoToggle == true) {
if (band == 0) Stereostatus = radio.getStereoStatus(); else Stereostatus = 0;
if (Stereostatus != Stereostatusold)
{
if (Stereostatus == true && screenmute == false)
{
if (Stereostatus != Stereostatusold) {
if (Stereostatus == true && screenmute == false) {
tft.drawCircle(81, 15, 10, TFT_RED);
tft.drawCircle(81, 15, 9, TFT_RED);
tft.drawCircle(91, 15, 10, TFT_RED);
@@ -1934,8 +1924,7 @@ void ShowModLevel() {
color = TFT_GREEN;
if (segments > 8) color = TFT_ORANGE;
if (segments > 9) color = TFT_RED;
if (MStatus > (segments + 1) * 10)
{
if (MStatus > (segments + 1) * 10) {
hold = segments;
tft.fillRect(20 + segments * 14, 139, 12, 8, color);
} else {
@@ -2239,8 +2228,7 @@ void ShowUSBstatus() {
}
void XDRGTKRoutine() {
if (Serial.available() > 0)
{
if (Serial.available()) {
buff[buff_pos] = Serial.read();
if (buff[buff_pos] != '\n' && buff_pos != 16 - 1) {
buff_pos++;
@@ -2248,8 +2236,7 @@ void XDRGTKRoutine() {
buff[buff_pos] = 0;
buff_pos = 0;
switch (buff[0])
{
switch (buff[0]) {
case 'x':
Serial.println("OK");
if (band != 0) {
@@ -2370,7 +2357,7 @@ void XDRGTKRoutine() {
band = 1;
SelectBand();
} else {
radio.setFrequency_AM(frequency_AM);
radio.SetFreqAM(frequency_AM);
}
Serial.print("M1\n");
} else if (freqtemp > 64999 && freqtemp < 108001) {
@@ -2380,7 +2367,7 @@ void XDRGTKRoutine() {
SelectBand();
Serial.print("M0\n");
} else {
radio.setFrequency(frequency, 65, 108, fullsearchrds);
radio.SetFreq(frequency);
}
}
if (band == 0) Serial.print("T" + String(frequency * 10) + "\n"); else Serial.print("T" + String(frequency_AM) + "\n");
@@ -2390,22 +2377,17 @@ void XDRGTKRoutine() {
break;
case 'S':
if (buff[1] == 'a')
{
if (buff[1] == 'a') {
scanner_start = (atol(buff + 2) + 5) / 10;
} else if (buff[1] == 'b')
{
} else if (buff[1] == 'b') {
scanner_end = (atol(buff + 2) + 5) / 10;
} else if (buff[1] == 'c')
{
} else if (buff[1] == 'c') {
scanner_step = (atol(buff + 2) + 5) / 10;
} else if (buff[1] == 'f')
{
} else if (buff[1] == 'f') {
scanner_filter = atol(buff + 2);
} else if (scanner_start > 0 && scanner_end > 0 && scanner_step > 0 && scanner_filter >= 0)
{
frequencyold = radio.getFrequency();
radio.setFrequency(scanner_start, 65, 108, fullsearchrds);
} else if (scanner_start > 0 && scanner_end > 0 && scanner_step > 0 && scanner_filter >= 0) {
frequencyold = frequency;
radio.SetFreq(scanner_start);
Serial.print('U');
if (scanner_filter < 0) {
BWset = 0;
@@ -2451,17 +2433,12 @@ void XDRGTKRoutine() {
tft.print("SCANNING...");
}
frequencyold = frequency / 10;
for (freq_scan = scanner_start; freq_scan <= scanner_end; freq_scan += scanner_step)
{
radio.setFrequency(freq_scan, 65, 108, fullsearchrds);
for (freq_scan = scanner_start; freq_scan <= scanner_end; freq_scan += scanner_step) {
radio.SetFreq(freq_scan);
Serial.print(freq_scan * 10, DEC);
Serial.print('=');
delay(10);
if (band == 0) {
radio.getStatus(SStatus, USN, WAM, OStatus, BW, MStatus);
} else {
radio.getStatus_AM(SStatus, USN, WAM, OStatus, BW, MStatus);
}
if (band == 0) radio.getStatus(SStatus, USN, WAM, OStatus, BW, MStatus); else radio.getStatusAM(SStatus, USN, WAM, OStatus, BW, MStatus);
Serial.print((SStatus / 10) + 10, DEC);
Serial.print(',');
}
@@ -2472,7 +2449,7 @@ void XDRGTKRoutine() {
tft.setCursor (90, 60);
tft.print("SCANNING...");
}
radio.setFrequency(frequencyold, 65, 108, fullsearchrds);
radio.SetFreq(frequencyold);
if (screenmute == false) ShowFreq(0);
radio.setFMABandw();
}
@@ -2545,10 +2522,93 @@ void XDRGTKRoutine() {
}
}
void TuneUp() {
unsigned int temp;
if (stepsize == 0) {
if (band == 1) {
if (frequency_AM < 1998) {
temp = 9;
frequency_AM = (frequency_AM / 9) * 9;
} else {
temp = 5;
frequency_AM = (frequency_AM / 5) * 5;
}
} else {
temp = 5;
}
}
if (stepsize == 1) temp = 1;
if (stepsize == 2) temp = 10;
if (stepsize == 3) temp = 100;
if (stepsize == 4) temp = 1000;
if (band == 0) {
frequency += temp;
if (frequency >= (HighEdgeSet * 100) + 1) {
frequency = LowEdgeSet * 100;
}
radio.SetFreq(frequency);
}
if (band == 1) {
frequency_AM += temp;
if (frequency_AM > 27000) {
frequency_AM = 144;
}
radio.SetFreqAM(frequency_AM);
}
radio.clearRDS(fullsearchrds);
}
void TuneDown() {
unsigned int temp;
if (stepsize == 0) {
if (band == 1) {
if (frequency_AM <= 2000) {
if (frequency_AM == 2000) {
frequency_AM = 1998;
temp = 0;
} else {
temp = 9;
frequency_AM = (frequency_AM / 9) * 9;
}
} else {
temp = 5;
frequency_AM = (frequency_AM / 5) * 5;
}
} else {
temp = 5;
}
}
if (stepsize == 1) temp = 1;
if (stepsize == 2) temp = 10;
if (stepsize == 3) temp = 100;
if (stepsize == 4) temp = 1000;
if (band == 0) {
frequency -= temp;
if (frequency < LowEdgeSet * 100) frequency = HighEdgeSet * 100;
radio.SetFreq(frequency);
}
if (band == 1) {
if (temp == 1000 && frequency_AM <= 1440)
{
frequency_AM = 27000;
} else {
frequency_AM -= temp;
if (frequency_AM < 144) frequency_AM = 27000;
}
radio.SetFreqAM(frequency_AM);
}
radio.clearRDS(fullsearchrds);
}
void Seek(bool mode) {
if (band == 0) {
radio.setMute();
if (mode == false) frequency = radio.tuneDown(stepsize, LowEdgeSet, HighEdgeSet, fullsearchrds); else frequency = radio.tuneUp(stepsize, LowEdgeSet, HighEdgeSet, fullsearchrds);
if (mode == false) TuneDown(); else TuneUp();
delay(50);
ShowFreq(0);
if (USBstatus == true) if (band == 0) Serial.print("T" + String(frequency * 10) + "\n"); else Serial.print("T" + String(frequency_AM) + "\n");

437
src/TEF6686.cpp
View File

@@ -40,27 +40,16 @@ const char* const PTY[]
void TEF6686::init(byte TEF) {
uint8_t bootstatus;
Tuner_I2C_Init();
getBootStatus(bootstatus);
devTEF_APPL_Get_Operation_Status(&bootstatus);
if (bootstatus == 0) {
Tuner_Patch(TEF);
delay(50);
if (digitalRead(15) == LOW) {
Tuner_Init9216();
} else {
Tuner_Init4000();
}
if (digitalRead(15) == LOW) Tuner_Init9216(); else Tuner_Init4000();
power(1);
Tuner_Init();
}
}
void TEF6686::power(uint8_t mode) {
devTEF_APPL_Set_OperationMode(mode);
if (mode == 0) {
devTEF_Set_Cmd(TEF_FM, Cmd_Tune_To, 7, 1, 10000);
}
}
bool TEF6686::getIdentification(uint16_t &device, uint16_t &hw_version, uint16_t &sw_version) {
bool result = devTEF_Radio_Get_Identification(&device, &hw_version, &sw_version);
return device;
@@ -68,70 +57,75 @@ bool TEF6686::getIdentification(uint16_t &device, uint16_t &hw_version, uint16_t
return sw_version;
}
void TEF6686::setFrequency(uint16_t frequency, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds) {
Radio_SetFreq(frequency, LowEdge, HighEdge, fullsearchrds);
void TEF6686::power(bool mode) {
devTEF_APPL_Set_OperationMode(mode);
if (mode == 0) devTEF_Set_Cmd(TEF_FM, Cmd_Tune_To, 7, 1, 10000);
}
void TEF6686::setFrequency_AM(uint16_t frequency) {
Radio_SetFreq_AM(frequency);
void TEF6686::SetFreq(uint16_t frequency) {
devTEF_Radio_Tune_To(frequency);
}
uint16_t TEF6686::getFrequency() {
return Radio_GetCurrentFreq();
void TEF6686::SetFreqAM(uint16_t frequency) {
devTEF_Radio_Tune_AM (frequency);
}
uint16_t TEF6686::getFrequency_AM() {
return Radio_GetCurrentFreq_AM();
}
void TEF6686::setOffset(int16_t offset) {
void TEF6686::setOffset(int8_t offset) {
devTEF_Radio_Set_LevelOffset(offset * 10);
}
void TEF6686::setFMBandw(uint16_t bandwidth) {
devTEF_Radio_Set_Bandwidth(0, bandwidth * 10, 1000, 1000);
}
void TEF6686::setAMBandw(uint16_t bandwidth) {
devTEF_Radio_Set_BandwidthAM(0, bandwidth * 10, 1000, 1000);
}
void TEF6686::setAMCoChannel(uint16_t start) {
devTEF_Radio_Set_CoChannel_AM(start * 10);
}
void TEF6686::setSoftmuteAM(uint8_t mode) {
devTEF_Radio_Set_Softmute_Max_AM(mode);
}
void TEF6686::setSoftmuteFM(uint8_t mode) {
devTEF_Radio_Set_Softmute_Max_FM(mode);
}
void TEF6686::setAMNoiseBlanker(uint16_t start) {
if (start == 0) devTEF_Radio_Set_Noiseblanker_AM(0, 1000); else devTEF_Radio_Set_Noiseblanker_AM(1, (start * 10) + 500);
}
void TEF6686::setAMAttenuation(uint16_t start) {
devTEF_Radio_Set_Attenuator_AM(start * 10);
}
void TEF6686::setFMABandw() {
devTEF_Radio_Set_Bandwidth(1, 3110, 1000, 1000);
}
void TEF6686::setAMBandw(uint16_t bandwidth) {
devTEF_Radio_Set_Bandwidth_AM(0, bandwidth * 10, 1000, 1000);
}
void TEF6686::setiMS(uint16_t mph) {
void TEF6686::setiMS(bool mph) {
devTEF_Radio_Set_MphSuppression(mph);
}
void TEF6686::setEQ(uint16_t eq) {
void TEF6686::setEQ(bool eq) {
devTEF_Radio_Set_ChannelEqualizer(eq);
}
bool TEF6686::getStereoStatus() {
return Radio_CheckStereo();
uint16_t status;
bool stereo = 0;
if (1 == devTEF_Radio_Get_Stereo_Status(&status)) stereo = ((status >> 15) & 1) ? 1 : 0;
return stereo;
}
void TEF6686::setMono(uint8_t mono) {
void TEF6686::setMono(bool mono) {
devTEF_Radio_Set_Stereo_Min(mono);
}
uint16_t TEF6686::tuneUp(uint8_t stepsize, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds) {
return tune(1, stepsize, LowEdge, HighEdge, fullsearchrds);
}
uint16_t TEF6686::tuneDown(uint8_t stepsize, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds) {
return tune(0, stepsize, LowEdge, HighEdge, fullsearchrds);
}
uint16_t TEF6686::tuneUp_AM(uint8_t stepsize) {
return tune_AM(1, stepsize);
}
uint16_t TEF6686::tuneDown_AM(uint8_t stepsize) {
return tune_AM(0, stepsize);
}
void TEF6686::setVolume(int16_t volume) {
void TEF6686::setVolume(int8_t volume) {
devTEF_Audio_Set_Volume(volume);
}
@@ -143,34 +137,47 @@ void TEF6686::setUnMute() {
devTEF_Audio_Set_Mute(0);
}
void TEF6686::setAGC(uint8_t start) {
if (start == 0) {
devTEF_Radio_Set_RFAGC(920);
}
if (start == 1) {
devTEF_Radio_Set_RFAGC(900);
}
if (start == 2) {
devTEF_Radio_Set_RFAGC(870);
}
if (start == 3) {
devTEF_Radio_Set_RFAGC(840);
}
void TEF6686::setAGC(uint8_t agc) {
if (agc == 0) devTEF_Radio_Set_RFAGC(920);
if (agc == 1) devTEF_Radio_Set_RFAGC(900);
if (agc == 2) devTEF_Radio_Set_RFAGC(870);
if (agc == 3) devTEF_Radio_Set_RFAGC(840);
}
void TEF6686::setDeemphasis(uint8_t timeconstant) {
if (timeconstant == 0) {
devTEF_Radio_Set_Deemphasis(500);
}
if (timeconstant == 1) {
devTEF_Radio_Set_Deemphasis(750);
}
if (timeconstant == 2) {
devTEF_Radio_Set_Deemphasis(0);
}
if (timeconstant == 1) devTEF_Radio_Set_Deemphasis(500);
if (timeconstant == 2) devTEF_Radio_Set_Deemphasis(750);
if (timeconstant == 3) devTEF_Radio_Set_Deemphasis(0);
}
void TEF6686::setStereoLevel(uint16_t start) {
void TEF6686::setAudio(uint8_t audio) {
if (audio == 1) devTEF_Radio_Specials(0);
if (audio == 2) devTEF_Radio_Specials(1);
}
void TEF6686::setFMSI(uint8_t mode) {
if (mode == 1) devTEF_APPL_Set_StereoImprovement(0);
if (mode == 2) devTEF_APPL_Set_StereoImprovement(1);
}
void TEF6686::setFMSI_Time(uint16_t attack, uint16_t decay) {
devTEF_APPL_Set_StereoBandBlend_Time(attack, decay);
}
void TEF6686::setFMSI_Gain(uint16_t band1, uint16_t band2, uint16_t band3, uint16_t band4) {
devTEF_APPL_Set_StereoBandBlend_Gain(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_APPL_Set_StereoBandBlend_Bias(band1 - 250, band2 - 250, band3 - 250, band4 - 250);
}
void TEF6686::setNoiseBlanker(uint16_t start) {
if (start == 0) devTEF_Radio_Set_NoisBlanker(0, 1000); else devTEF_Radio_Set_NoisBlanker(1, (start * 10) + 500);
}
void TEF6686::setStereoLevel(uint8_t start) {
if (start == 0) {
devTEF_Radio_Set_Stereo_Level(0, start * 10, 60);
devTEF_Radio_Set_Stereo_Noise(0, 240, 200);
@@ -182,7 +189,7 @@ void TEF6686::setStereoLevel(uint16_t start) {
}
}
void TEF6686::setHighCutOffset(uint16_t start) {
void TEF6686::setHighCutOffset(uint8_t start) {
if (start == 0) {
devTEF_Radio_Set_Highcut_Level(0, start * 10, 300);
devTEF_Radio_Set_Highcut_Noise(0, 360, 300);
@@ -198,13 +205,35 @@ void TEF6686::setHighCutLevel(uint16_t limit) {
devTEF_Radio_Set_Highcut_Max(1, limit * 100);
}
bool TEF6686::getBootStatus(uint8_t &bootstatus) {
uint8_t result = devTEF_APPL_Get_Operation_Status(&bootstatus);
return bootstatus;
void TEF6686::setStHiBlendLevel(uint16_t limit) {
devTEF_Radio_Set_StHiBlend_Max(1, limit * 100);
}
void TEF6686::setStHiBlendOffset(uint8_t start) {
if (start == 0) {
devTEF_Radio_Set_StHiBlend_Level(0, start * 10, 300);
devTEF_Radio_Set_StHiBlend_Noise(0, 360, 300);
devTEF_Radio_Set_StHiBlend_Mph(0, 360, 300);
} else {
devTEF_Radio_Set_StHiBlend_Level(3, start * 10, 300);
devTEF_Radio_Set_StHiBlend_Noise(3, 360, 300);
devTEF_Radio_Set_StHiBlend_Mph(3, 360, 300);
}
}
bool TEF6686::getProcessing(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) {
bool result = devTEF_Radio_Get_Processing_Status(&highcut, &stereo, &sthiblend, &stband_1, &stband_2, &stband_3, &stband_4);
return highcut;
return stereo;
return sthiblend;
return stband_1;
return stband_2;
return stband_3;
return stband_4;
}
bool TEF6686::getStatus(int16_t &level, uint16_t &USN, uint16_t &WAM, int16_t &offset, uint16_t &bandwidth, uint16_t &modulation) {
uint8_t result = devTEF_Radio_Get_Quality_Status(&level, &USN, &WAM, &offset, &bandwidth, &modulation);
bool result = devTEF_Radio_Get_Quality_Status(&level, &USN, &WAM, &offset, &bandwidth, &modulation);
return level;
return USN;
return WAM;
@@ -212,35 +241,38 @@ bool TEF6686::getStatus(int16_t &level, uint16_t &USN, uint16_t &WAM, int16_t &o
return modulation;
}
bool TEF6686::getStatus_AM(int16_t &level, uint16_t &USN, uint16_t &WAM, int16_t &offset, uint16_t &bandwidth, uint16_t &modulation) {
uint8_t result = devTEF_Radio_Get_Quality_Status_AM(&level, &USN, &WAM, &offset, &bandwidth, &modulation);
bool TEF6686::getStatusAM(int16_t &level, uint16_t &noise, uint16_t &cochannel, int16_t &offset, uint16_t &bandwidth, uint16_t &modulation) {
bool result = devTEF_Radio_Get_Quality_Status_AM(&level, &noise, &cochannel, &offset, &bandwidth, &modulation);
return level;
return USN;
return WAM;
return noise;
return cochannel;
return bandwidth;
return modulation;
}
bool TEF6686::readRDS()
{
char status;
uint16_t rdsStat = 0, rdsErr = 65535, rdsErrA = 65535, rdsErrB = 65535, rdsErrC = 65535, rdsErrD = 65535;
uint16_t result = devTEF_Radio_Get_RDS_Data(&rdsStat, &rds.rdsA, &rds.rdsB, &rds.rdsC, &rds.rdsD, &rdsErr);
uint8_t rds_group;
uint8_t offset;
bool rdsErrCheck = false, rdsDataReady = false;
char status;
uint16_t rdsStat = 0, rdsErr = 65535, rdsErrA = 65535, rdsErrB = 65535, rdsErrC = 65535, rdsErrD = 65535;
uint16_t result = devTEF_Radio_Get_RDS_Data(&rdsStat, &rds.rdsA, &rds.rdsB, &rds.rdsC, &rds.rdsD, &rdsErr);
uint8_t rds_group;
uint8_t offset;
bool rdsErrCheck = false, rdsDataReady = false;
rdsErrA = ((rdsErr >> 14) & 0x02);
rdsErrB = ((rdsErr >> 12) & 0x02);
rdsErrC = ((rdsErr >> 10) & 0x02);
rdsErrD = ((rdsErr >> 8) & 0x02);
rdsTimeOut += rdsErr == 0 && rds.rdsA != 0 ? -rdsTimeOut : rdsTimeOut < 32768 ? 1 : 0;
rds.hasRDS = rdsTimeOut < 32768 ? true : false;
rdsErrCheck = rdsErr == 0;
rdsDataReady = ((rdsStat & (1 << 15)) && (rdsStat & (1 << 9)));
rdsDataReady = ((rdsStat & (1 << 15)) && (rdsStat & (1 << 9)));
rds.errors = rdsErr;
if (rdsDataReady && rdsErrCheck)
if (rdsDataReady)
{
//RDS PI
//PI
if (rds.stationID == 0) rds.stationID = rds.rdsA;
char Hex[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
rds.picode[0] = Hex[(rds.rdsA & 0xF000U) >> 12];
@@ -249,42 +281,79 @@ bool TEF6686::readRDS()
rds.picode[3] = Hex[(rds.rdsA & 0x000FU)];
rds.picode[4] = '\0';
rds_group = (rds.rdsB >> 11);
if (rdsErrCheck) rds.correct = true; else rds.correct = false;
switch (rds_group)
{
case RDS_GROUP_0A:
case RDS_GROUP_0B:
{
//RDS PS
//RDS Programm-Service
offset = rds.rdsB & 0x03;
if ((offset == 0) && (ps_process == 0)) ps_process = 1;
if ((offset == 0) && (ps_process == 0))ps_process = 1;
if (ps_process == 1)
{
if (ps_process == 1) {
ps_buffer[(offset * 2) + 0] = ascii_converter(rds.rdsD >> 8);
ps_buffer[(offset * 2) + 1] = ascii_converter(rds.rdsD & 0xFF);
ps_buffer[(offset * 2) + 2] = 0;
ps_process = strlen(ps_buffer) == 8 ? 2 : 1;
}
if (ps_process == 2)
{
if (ps_process == 2) {
strcpy(rds.stationName, ps_buffer);
for (int i = 0; i < 9; i++)
ps_buffer[i] = '\0';
for (int i = 0; i < 9; i++) ps_buffer[i] = '\0';
ps_process = 0;
rds.hasPS = true;
}
//RDS PTY Code
//PTY
rds.stationTypeCode = (rds.rdsB >> 5) & 0x1F;
rds.hasPTY = true;
strcpy(rds.stationType, PTY[rds.stationTypeCode]);
//TP-TA-EON-MS
if ((bitRead(rds.rdsB, 4)) == 1 && ((bitRead(rds.rdsB, 10)) == 0)) rds.hasEON = true; else rds.hasEON = false;
if ((bitRead(rds.rdsB, 4)) == 0 && ((bitRead(rds.rdsB, 10)) == 1)) rds.hasTP = true; else rds.hasTP = false;
rds.hasTA = (bitRead(rds.rdsB, 4)) && (bitRead(rds.rdsB, 10)) & 0x1F;
rds.MS = (bitRead(rds.rdsB, 3)) & 0x1F;
//AF
uint8_t af_controlCode = rds.rdsC >> 8;
if ((af_controlCode < 224) && (af_counter < 50))
{
uint16_t buffer0 = (rds.rdsC >> 8);
uint16_t buffer1 = (rds.rdsC & 0xFF);
rds.hasAF = true;
if (buffer0 != 0 && buffer1 != 0)
{
buffer0 = buffer0 * 10 + 8750;
buffer1 = buffer1 * 10 + 8750;
bool isDouble = false;
isDouble = checkDouble(buffer0);
if (!isDouble && buffer0 != 0) {
af[af_counter].frequency = buffer0;
af_counter++;
}
isDouble = checkDouble(buffer1);
if (!isDouble && buffer1 != 0) {
af[af_counter].frequency = buffer1;
af_counter++;
}
}
}
} break;
case RDS_GROUP_1A:
if (rds.rdsC < 255) rds.ECC = rds.rdsC;
break;
case RDS_GROUP_2A:
case RDS_GROUP_2B:
{
//RDS RT Code
boolean limit_reached = false;
rds.hasRT = true;
offset = (rds.rdsB & 0xf) * 4;
rds.rtAB = (bitRead(rds.rdsB, 4));
limit_reached = (offset == 60 || (rds.rdsC >> 8) == '\r' || (rds.rdsC & 0xFF) == '\r' || (rds.rdsD >> 8) == '\r' || (rds.rdsD & 0xFF) == '\r') ? true : false;
@@ -292,17 +361,14 @@ bool TEF6686::readRDS()
if (rds.rtAB != ABold) {
offsetold = 0;
for (int i = 0; i < 65; i++) {
rds.stationText[i] = 0;
}
if (rt_timer == 64) {
strcpy(rds.stationText, stationTextBuffer);
}
for (int i = 0; i < 65; i++) rds.stationText[i] = 0;
if (rt_timer == 64) strcpy(rds.stationText, stationTextBuffer);
for (int i = 0; i < 65; i++) {
rt_buffer[i] = 0;
stationTextBuffer[i] = 0;
}
rt_process = 0;
if (rds.hasRDSplus == false) rt_process = 0;
}
ABold = rds.rtAB;
@@ -320,9 +386,8 @@ bool TEF6686::readRDS()
rt_buffer[offset + 2] = ascii_converter(rds.rdsD >> 8);
rt_buffer[offset + 3] = ascii_converter(rds.rdsD & 0xff);
if (offset > offsetold) {
offsetold = offset;
}
if (offset > offsetold) offsetold = offset;
if (offset == offsetold) {
strcpy(stationTextBuffer, rt_buffer);
if (rt_timer < 64) {
@@ -339,6 +404,7 @@ bool TEF6686::readRDS()
{
for (int i = 0; i < 64; i++)
{
rt_buffer2[i] = rt_buffer[i];
rt_buffer[i] = 0;
}
}
@@ -347,7 +413,26 @@ bool TEF6686::readRDS()
case RDS_GROUP_4A:
case RDS_GROUP_4B:
{
//RDS CT
uint32_t mjd;
rds.hasCT = true;
mjd = (rds.rdsB & 0x03);
mjd <<= 15;
mjd += ((rds.rdsC >> 1) & 0x7FFF);
long J, C, Y, M;
uint8_t LocalOffset;
J = mjd + 2400001 + 68569;
C = 4 * J / 146097;
J = J - (146097 * C + 3) / 4;
Y = 4000 * (J + 1) / 1461001;
J = J - 1461 * Y / 4 + 31;
M = 80 * (J + 0) / 2447;
rds.days = J - 2447 * M / 80;
J = M / 11;
rds.months = M + 2 - (12 * J);
rds.years = 100 * (C - 49) + Y + J;
rds.hours = ((rds.rdsD >> 12) & 0x0f);
rds.hours += ((rds.rdsC << 4) & 0x0010);
rds.minutes = ((rds.rdsD >> 6) & 0x3f);
@@ -355,6 +440,77 @@ bool TEF6686::readRDS()
rds.offset = (rds.rdsD & 0x3f);
rds.hasCT = true;
} break;
case RDS_GROUP_10A:
case RDS_GROUP_10B:
case RDS_GROUP_11A:
case RDS_GROUP_11B:
case RDS_GROUP_12A:
case RDS_GROUP_12B:
{
if (useRTPlus)
{
uint16_t content_byte_1 = (rds.rdsB & 0x07);
content_byte_1 = (content_byte_1 << 0x03);
content_byte_1 += (rds.rdsC >> 0x0D);
uint16_t content_byte_2 = (rds.rdsC & 0x01);
content_byte_2 = (content_byte_2 << 0x05);
content_byte_2 += (rds.rdsD >> 0x0B);
uint16_t start_marker_1 = (rds.rdsC >> 0x07);
start_marker_1 = (start_marker_1 & 0x3F);
uint16_t length_marker_1 = (rds.rdsC >> 0x01);
length_marker_1 = (length_marker_1 & 0x3F);
uint16_t start_marker_2 = (rds.rdsD >> 0x05);
start_marker_2 = (start_marker_2 & 0x3F);
uint16_t length_marker_2 = (rds.rdsD & 0x1F);
rds.hasRDSplus = true;
if (rt_process == 2)
{
if (content_byte_1 == 0x04) { //ArtistID
rds.hasMusicArtist = true;
for (int i = 0; i <= length_marker_1; i++)rds.musicArtist[i] = rt_buffer2[i + start_marker_1];
rds.musicArtist[length_marker_1 + 1] = 0;
}
else if (content_byte_1 == 0x01) {//TitleID
rds.hasMusicTitle = true;
for (int i = 0; i <= length_marker_1; i++)rds.musicTitle[i] = rt_buffer2[i + start_marker_1];
rds.musicTitle[length_marker_1 + 1] = 0;
}
if (content_byte_2 == 0x04) {//ArtistID
rds.hasMusicArtist = true;
for (int i = 0; i <= length_marker_2; i++)rds.musicArtist[i] = rt_buffer2[i + start_marker_2];
rds.musicArtist[length_marker_2 + 1] = 0;
}
else if (content_byte_2 == 0x01) {//TitleID
rds.hasMusicTitle = true;
for (int i = 0; i <= length_marker_2; i++)rds.musicTitle[i] = rt_buffer2[i + start_marker_2];
rds.musicTitle[length_marker_2 + 1] = 0;
}
if (content_byte_1 == 0x24) {//HostID
rds.hasStationHost = true;
for (int i = 0; i <= length_marker_1; i++)rds.stationHost[i] = rt_buffer2[i + start_marker_1];
rds.stationHost[length_marker_1 + 1] = 0;
}
else if (content_byte_2 == 0x24) {
rds.hasStationHost = true;
for (int i = 0; i <= length_marker_2; i++)rds.stationHost[i] = rt_buffer2[i + start_marker_2];
rds.stationHost[length_marker_2 + 1] = 0;
}
if (content_byte_1 == 0x21) {//EventID
rds.hasStationEvent = true;
for (int i = 0; i <= length_marker_1; i++)rds.stationEvent[i] = rt_buffer2[i + start_marker_1];
rds.stationEvent[length_marker_1 + 1] = 0;
}
else if (content_byte_2 == 0x21) {
rds.hasStationEvent = true;
for (int i = 0; i <= length_marker_2; i++)rds.stationEvent[i] = rt_buffer2[i + start_marker_2];
rds.stationEvent[length_marker_2 + 1] = 0;
}
rt_process = 0;
}
}
} break;
}
}
return rdsDataReady;
@@ -377,6 +533,12 @@ uint8_t TEF6686::ascii_converter (uint8_t src)
return (dest);
}
bool TEF6686::checkDouble (uint16_t value)
{
for (int i = 0; i < 50; i++) if (af[i].frequency == value)return (true);
return (false);
}
void TEF6686::clearRDS (bool fullsearchrds)
{
devTEF_Radio_Set_RDS(fullsearchrds);
@@ -389,44 +551,55 @@ void TEF6686::clearRDS (bool fullsearchrds)
rds.stationText[i] = 0;
stationTextBuffer[i] = 0;
rt_buffer[i] = 0;
rt_buffer2[i] = 0;
}
for (i = 0; i < 17; i++) {
rds.stationType[i] = 0;
}
for (i = 0; i < 5; i++) {
rds.picode[i] = 0;
for (i = 0; i < 32; i++) {
rds.musicArtist[i] = 0;
rds.musicTitle[i] = 0;
rds.stationEvent[i] = 0;
rds.stationHost[i] = 0;
}
for (i = 0; i < 5; i++) rds.picode[i] = 0;
for (i = 0; i < 50; i++) af[i].frequency = 0;
rds.stationType[i] = '\0';
rds.stationID = 0;
rds.ECC = 0;
offsetold = 0;
rds.stationTypeCode = 32;
rdsTimeOut = 32768;
rds.hasRDSplus = false;
rds.afclear = false;
rds.hasRT = false;
rds.hasRDS = false;
rds.hasPS = false;
rds.hasTP = false;
rds.hasTA = false;
rds.hasEON = false;
rds.MS = false;
rds.hasPTY = false;
rds.hasCT = false;
rds.hasMusicTitle = false;
rds.hasMusicArtist = false;
rds.hasStationEvent = false;
rds.hasStationHost = false;
rds.stationTextOffset = 0;
rds.errors = 0;
rds.correct = 0;
rt_process = 0;
ps_process = 1;
af_counter = 0;
rt_timer = 0;
rds.errors = 0;
}
uint16_t TEF6686::tune(uint8_t up, uint8_t stepsize, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds) {
Radio_ChangeFreqOneStep(up, stepsize, LowEdge, HighEdge, fullsearchrds);
Radio_SetFreq(Radio_GetCurrentFreq(), LowEdge, HighEdge, fullsearchrds);
return Radio_GetCurrentFreq();
}
uint16_t TEF6686::tune_AM(uint8_t up, uint8_t stepsize) {
Radio_ChangeFreqOneStep_AM(up, stepsize);
Radio_SetFreq_AM(Radio_GetCurrentFreq_AM());
return Radio_GetCurrentFreq_AM();
}
void TEF6686::tone(uint16_t time, int16_t amplitude, uint16_t frequency) {
devTEF_Audio_Set_Mute(0);
devTEF_Radio_Set_Wavegen(1, amplitude, frequency);
delay (time);
devTEF_Radio_Set_Wavegen(0, 0, 0);
devTEF_Audio_Set_Mute(0);
devTEF_Radio_Set_Wavegen(1, amplitude, frequency);
delay (time);
devTEF_Radio_Set_Wavegen(0, 0, 0);
}

100
src/TEF6686.h
View File

@@ -1,79 +1,111 @@
#define TEF6686_h
#include "Arduino.h"
#include "Tuner_Api.h"
#include "Tuner_Drv_Lithio.h"
#include "Tuner_Interface.h"
enum RDS_GROUPS
{
enum RDS_GROUPS {
RDS_GROUP_0A, RDS_GROUP_0B, RDS_GROUP_1A, RDS_GROUP_1B, RDS_GROUP_2A, RDS_GROUP_2B, RDS_GROUP_3A, RDS_GROUP_3B,
RDS_GROUP_4A, RDS_GROUP_4B, RDS_GROUP_5A, RDS_GROUP_5B, RDS_GROUP_6A, RDS_GROUP_6B, RDS_GROUP_7A, RDS_GROUP_7B,
RDS_GROUP_8A, RDS_GROUP_8B, RDS_GROUP_9A, RDS_GROUP_9B, RDS_GROUP_10A, RDS_GROUP_10B, RDS_GROUP_11A, RDS_GROUP_11B,
RDS_GROUP_12A, RDS_GROUP_12B, RDS_GROUP_13A, RDS_GROUP_13B, RDS_GROUP_14A, RDS_GROUP_14B, RDS_GROUP_15A, RDS_GROUP_15B
};
typedef struct _rds_
{
char picode[5];
typedef struct _rds_ {
byte stationTypeCode;
char stationName[9];
char stationText[65];
byte stationTypeCode;
char stationType[17];
uint16_t hours, minutes, days, offsetplusmin, stationID = 0, rdsA, rdsB, rdsC, rdsD, rdsError, errors = 0;
char musicTitle[48];
char musicArtist[48];
char stationHost[48];
char stationEvent[48];
char picode[5];
uint16_t hours, minutes, days, months, years, offsetplusmin, stationID = 0, rdsA, rdsB, rdsC, rdsD, rdsError, errors = 0;
int8_t offset;
uint8_t stationTextOffset = 0;
bool hasCT = false;
bool rtAB = false;
int ECC;
bool hasMusicTitle;
bool hasMusicArtist;
bool hasStationHost;
bool hasStationEvent;
bool hasRDSplus;
bool hasRDS;
bool hasPS;
bool hasRT;
bool hasTP;
bool hasTA;
bool hasEON;
bool hasAF;
bool MS;
bool hasPTY;
bool hasCT;
bool afclear;
bool rtAB;
bool correct;
} rds_;
typedef struct _af_ {
uint16_t frequency;
} af_;
class TEF6686 {
public:
af_ af[50];
rds_ rds;
bool readRDS(void);
uint16_t getFrequency();
uint16_t getFrequency_AM();
uint16_t tuneDown(uint8_t stepsize, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds);
uint16_t tuneUp(uint8_t stepsize, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds);
uint16_t tuneDown_AM(uint8_t stepsize);
uint16_t tuneUp_AM(uint8_t stepsize);
void SetFreq(uint16_t frequency);
void SetFreqAM(uint16_t frequency);
bool getProcessing(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);
bool getStatus(int16_t &level, uint16_t &USN, uint16_t &WAM, int16_t &offset, uint16_t &bandwidth, uint16_t &modulation);
bool getStatus_AM(int16_t &level, uint16_t &USN, uint16_t &WAM, int16_t &offset, uint16_t &bandwidth, uint16_t &modulation);
bool getStatusAM(int16_t &level, uint16_t &noise, uint16_t &cochannel, int16_t &offset, uint16_t &bandwidth, uint16_t &modulation);
bool getIdentification(uint16_t &device, uint16_t &hw_version, uint16_t &sw_version);
bool getBootStatus(uint8_t &bootstatus);
void setMono(uint8_t mono);
void setSoftmuteFM(uint8_t mode);
void setSoftmuteAM(uint8_t mode);
void setMono(bool mono);
bool getStereoStatus();
void init(byte TEF);
void clearRDS(bool fullsearchrds);
void power(uint8_t mode);
void setAGC(uint8_t start);
void setiMS(uint16_t mph);
void setEQ(uint16_t eq);
void power(bool mode);
void setAGC(uint8_t agc);
void setiMS(bool mph);
void setEQ(bool eq);
void setDeemphasis(uint8_t timeconstant);
void setAudio(uint8_t audio);
void setFMABandw();
void setFMBandw(uint16_t bandwidth);
void setAMBandw(uint16_t bandwidth);
void setFrequency(uint16_t frequency, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds);
void setFrequency_AM(uint16_t frequency);
void setHighCutLevel(uint16_t limit);
void setHighCutOffset(uint16_t start);
void setHighCutOffset(uint8_t start);
void setStHiBlendLevel(uint16_t limit);
void setStHiBlendOffset(uint8_t start);
void setNoiseBlanker(uint16_t start);
void setAMCoChannel(uint16_t start);
void setAMNoiseBlanker(uint16_t start);
void setAMAttenuation(uint16_t start);
void setMute();
void setOffset(int16_t offset);
void setStereoLevel(uint16_t start);
void setOffset(int8_t offset);
void setFMSI(uint8_t mode);
void setFMSI_Time(uint16_t attack, uint16_t decay);
void setFMSI_Gain(uint16_t band1, uint16_t band2, uint16_t band3, uint16_t band4);
void setFMSI_Bias(int16_t band1, int16_t band2, int16_t band3, int16_t band4);
void setStereoLevel(uint8_t start);
void setUnMute();
void setVolume(int16_t volume);
void tone(uint16_t time, int16_t amplitude, uint16_t frequency);
void setVolume(int8_t volume);
uint8_t af_counter;
void tone(uint16_t time, int16_t amplitude, uint16_t frequency);
private:
uint16_t tune(uint8_t up, uint8_t stepsize, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds);
uint16_t tune_AM(uint8_t up, uint8_t stepsize);
uint8_t ascii_converter (uint8_t src);
uint8_t ascii_converter (uint8_t src);
uint16_t rdsTimeOut = 32768;
uint8_t ps_process;
uint8_t rt_process;
char ps_buffer[9];
char rt_buffer[65];
char rt_buffer2[65];
bool useRTPlus = true;
bool checkDouble (uint16_t value);
bool ABold;
byte rt_timer;
byte offsetold;

106
src/Tuner_Api.cpp
View File

@@ -1,106 +0,0 @@
#include "TEF6686.h"
uint16_t Radio_CurrentFreq;
uint16_t Radio_CurrentFreq_AM;
void Radio_SetFreq(uint16_t Freq, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds)
{
if ((Freq > HighEdge * 100) || (Freq < LowEdge * 100)) {
Freq = LowEdge * 100;
}
Radio_CurrentFreq = Freq;
devTEF_Radio_Tune_To(Freq);
devTEF_Radio_Set_RDS(fullsearchrds);
}
void Radio_SetFreq_AM(uint16_t Freq)
{
if (Freq > 27000) {
Freq = 144;
}
if (Freq < 144) {
Freq = 27000;
}
Radio_CurrentFreq_AM = Freq;
devTEF_Radio_Tune_To_AM(Freq);
}
void Radio_ChangeFreqOneStep(uint8_t UpDown, uint8_t stepsize, uint16_t LowEdge, uint16_t HighEdge, bool fullseachrds)
{
byte temp;
if (stepsize == 0) {
temp = 5;
}
if (stepsize == 1) {
temp = 1;
}
if (stepsize == 2) {
temp = 10;
}
if (stepsize == 3) {
temp = 100;
}
if (UpDown == 1) {
Radio_CurrentFreq += temp;
if (Radio_CurrentFreq > HighEdge * 100) {
Radio_CurrentFreq = LowEdge * 100;
}
} else {
Radio_CurrentFreq -= temp;
if (Radio_CurrentFreq < LowEdge * 100) {
Radio_CurrentFreq = HighEdge * 100;
}
}
}
void Radio_ChangeFreqOneStep_AM(uint8_t UpDown, uint8_t stepsize)
{
byte temp;
if (stepsize == 0) {
if (Radio_CurrentFreq_AM < 2000) {
temp = 9;
} else {
temp = 5;
}
}
if (stepsize == 1) {
temp = 1;
}
if (stepsize == 2) {
temp = 10;
}
if (stepsize == 3) {
temp = 100;
}
if (UpDown == 1) {
Radio_CurrentFreq_AM += temp;
if (Radio_CurrentFreq_AM > 27000) {
Radio_CurrentFreq_AM = 144;
}
} else {
Radio_CurrentFreq_AM -= temp;
if (Radio_CurrentFreq_AM < 144) {
Radio_CurrentFreq_AM = 27000;
}
}
}
uint16_t Radio_GetCurrentFreq(void)
{
return Radio_CurrentFreq;
}
uint16_t Radio_GetCurrentFreq_AM(void)
{
return Radio_CurrentFreq_AM;
}
bool Radio_CheckStereo(void)
{
uint16_t status;
uint8_t stereo = 0;
if (1 == devTEF_Radio_Get_Stereo_Status(&status)) {
stereo = ((status >> 15) & 1) ? 1 : 0;
}
return stereo;
}

7
src/Tuner_Api.h
View File

@@ -1,7 +0,0 @@
extern uint16_t Radio_GetCurrentFreq(void);
extern uint16_t Radio_GetCurrentFreq_AM(void);
extern void Radio_ChangeFreqOneStep(uint8_t UpDown, uint8_t stepsize, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds);
extern void Radio_ChangeFreqOneStep_AM(uint8_t UpDown, uint8_t stepsize);
extern void Radio_SetFreq(uint16_t Freq, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds);
extern void Radio_SetFreq_AM(uint16_t Freq);
bool Radio_CheckStereo(void);

210
src/Tuner_Drv_Lithio.cpp
View File

@@ -1,40 +1,32 @@
#include "TEF6686.h"
#include <stdarg.h>
#define High_16bto8b(a) ((uint8_t)((a) >> 8))
#define Low_16bto8b(a) ((uint8_t)(a ))
#define High_16bto8b(a) ((uint8_t)((a) >> 8))
#define Low_16bto8b(a) ((uint8_t)(a ))
#define Convert8bto16b(a) ((uint16_t)(((uint16_t)(*(a))) << 8 |((uint16_t)(*(a+1)))))
bool devTEF_Set_Cmd(TEF_MODULE module, uint8_t cmd, uint16_t len, ...)
{
bool devTEF_Set_Cmd(TEF_MODULE module, uint8_t cmd, uint16_t len, ...) {
uint16_t i;
uint8_t buf[20];
uint16_t temp;
va_list vArgs;
va_start(vArgs, len);
buf[0] = module;
buf[1] = cmd;
buf[2] = 1;
for (i = 3; i < len; i++)
{
for (i = 3; i < len; i++) {
temp = va_arg(vArgs, int);
buf[i++] = High_16bto8b(temp);
buf[i] = Low_16bto8b(temp);
}
va_end(vArgs);
return Tuner_WriteBuffer(buf, len);
}
bool devTEF_Get_Cmd(TEF_MODULE module, uint8_t cmd, uint8_t *receive, uint16_t len)
{
bool devTEF_Get_Cmd(TEF_MODULE module, uint8_t cmd, uint8_t *receive, uint16_t len) {
uint8_t buf[3];
buf[0] = module;
buf[1] = cmd;
buf[2] = 1;
@@ -43,118 +35,176 @@ bool devTEF_Get_Cmd(TEF_MODULE module, uint8_t cmd, uint8_t *receive, uint16_t l
return Tuner_ReadBuffer(receive, len);
}
bool devTEF_Radio_Tune_To (uint16_t frequency)
{
bool devTEF_Radio_Tune_To (uint16_t frequency) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Tune_To, 7, 4, frequency);
}
bool devTEF_Radio_Tune_To_AM (uint16_t frequency)
{
bool devTEF_Radio_Tune_AM (uint16_t frequency) {
return devTEF_Set_Cmd(TEF_AM, Cmd_Tune_To, 7, 1, frequency);
}
bool devTEF_Radio_Set_Bandwidth(uint16_t mode, uint16_t bandwidth, uint16_t control_sensitivity, uint16_t low_level_sensitivity)
{
bool devTEF_Radio_Set_Bandwidth(uint8_t mode, uint16_t bandwidth, uint16_t control_sensitivity, uint16_t low_level_sensitivity) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Bandwidth, 11, mode, bandwidth, control_sensitivity, low_level_sensitivity);
}
bool devTEF_Radio_Set_Bandwidth_AM(uint16_t mode, uint16_t bandwidth, uint16_t control_sensitivity, uint16_t low_level_sensitivity)
{
bool devTEF_Radio_Set_BandwidthAM(uint8_t mode, uint16_t bandwidth, uint16_t control_sensitivity, uint16_t low_level_sensitivity) {
return devTEF_Set_Cmd(TEF_AM, Cmd_Set_Bandwidth, 7, mode, bandwidth, control_sensitivity, low_level_sensitivity);
}
bool devTEF_Radio_Set_LevelOffset(int16_t offset)
{
bool devTEF_Radio_Set_Noiseblanker_AM(uint8_t mode, uint16_t start) {
return devTEF_Set_Cmd(TEF_AM, Cmd_Set_NoiseBlanker, 7, mode, start);
return devTEF_Set_Cmd(TEF_AM, Cmd_Set_NoiseBlanker_Audio, 7, mode, 1000);
}
bool devTEF_Radio_Set_Attenuator_AM(uint16_t start) {
return devTEF_Set_Cmd(TEF_AM, Cmd_Set_Antenna, 5, start);
}
bool devTEF_Radio_Set_CoChannel_AM(uint16_t start) {
return devTEF_Set_Cmd(TEF_AM, Cmd_Set_CoChannelDet, 11, 1, 2, start, 1000, 3);
}
bool devTEF_Radio_Set_LevelOffset(int16_t offset) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_LevelOffset, 5, offset - 70);
}
bool devTEF_Radio_Set_Highcut_Level(uint16_t mode, uint16_t start, uint16_t slope)
{
bool devTEF_Radio_Set_RDS(bool fullsearchrds) {
if (fullsearchrds == true) return devTEF_Set_Cmd(TEF_FM, Cmd_Set_RDS, 9, 3, 1, 0); else return devTEF_Set_Cmd(TEF_FM, Cmd_Set_RDS, 9, 1, 1, 0);
}
bool devTEF_Radio_Set_Highcut_Level(uint8_t mode, uint16_t start, uint16_t slope) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Level, 9, mode, start, slope);
}
bool devTEF_Radio_Set_Highcut_Noise(uint16_t mode, uint16_t start, uint16_t slope)
{
bool devTEF_Radio_Set_Highcut_Noise(uint8_t mode, uint16_t start, uint16_t slope) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Noise, 9, mode, start, slope);
}
bool devTEF_Radio_Set_Highcut_Mph(uint16_t mode, uint16_t start, uint16_t slope)
{
bool devTEF_Radio_Set_Highcut_Mph(uint8_t mode, uint16_t start, uint16_t slope) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Mph, 9, mode, start, slope);
}
bool devTEF_Radio_Set_Highcut_Max(uint16_t mode, uint16_t limit)
{
bool devTEF_Radio_Set_Highcut_Max(uint8_t mode, uint16_t limit) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Max, 7, mode, limit);
}
bool devTEF_Radio_Set_Stereo_Level(uint16_t mode, uint16_t start, uint16_t slope)
{
bool devTEF_Radio_Set_StHiBlend_Level(uint8_t mode, uint16_t start, uint16_t slope) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Level, 9, mode, start, slope);
}
bool devTEF_Radio_Set_StHiBlend_Noise(uint8_t mode, uint16_t start, uint16_t slope) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Noise, 9, mode, start, slope);
}
bool devTEF_Radio_Set_StHiBlend_Mph(uint8_t mode, uint16_t start, uint16_t slope) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Mph, 9, mode, start, slope);
}
bool devTEF_Radio_Set_StHiBlend_Max(uint8_t mode, uint16_t limit) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Max, 7, mode, limit);
}
bool devTEF_Radio_Set_Stereo_Level(uint8_t mode, uint16_t start, uint16_t slope) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Level, 9, mode, start, slope);
}
bool devTEF_Radio_Set_Stereo_Noise(uint16_t mode, uint16_t start, uint16_t slope)
{
bool devTEF_Radio_Set_NoisBlanker(uint8_t mode, uint16_t start) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_NoiseBlanker, 7, mode, start);
}
bool devTEF_Radio_Set_Stereo_Noise(uint8_t mode, uint16_t start, uint16_t slope) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Noise, 9, mode, start, slope);
}
bool devTEF_Radio_Set_Stereo_Mph(uint16_t mode, uint16_t start, uint16_t slope)
{
bool devTEF_Radio_Set_Stereo_Mph(uint8_t mode, uint16_t start, uint16_t slope) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Mph, 9, mode, start, slope);
}
bool devTEF_Radio_Set_MphSuppression(uint16_t mph)
{
bool devTEF_Radio_Set_MphSuppression(bool mph) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_MphSuppression, 5, mph, 0);
}
bool devTEF_Radio_Set_ChannelEqualizer(uint16_t eq)
{
bool devTEF_Radio_Set_ChannelEqualizer(bool eq) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_ChannelEqualizer, 5, eq, 0);
}
bool devTEF_Radio_Set_Stereo_Min(uint16_t mode)
{
bool devTEF_Radio_Set_Stereo_Min(bool mode) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Min, 7, mode);
}
bool devTEF_Radio_Set_RFAGC(uint16_t start)
{
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_RFAGC, 7, start, 0, 0);
bool devTEF_Radio_Set_RFAGC(uint16_t agc) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_RFAGC, 7, agc, 0, 0);
}
bool devTEF_Radio_Set_Deemphasis(uint16_t timeconstant)
{
bool devTEF_Radio_Set_Deemphasis(uint16_t timeconstant) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Deemphasis, 5, timeconstant, 0);
}
bool devTEF_Audio_Set_Volume(int16_t volume)
{
bool devTEF_Radio_Specials(uint16_t audio) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Specials, 5, audio, 0);
}
bool devTEF_Audio_Set_Volume(int16_t volume) {
return devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Volume, 5, volume * 10);
}
bool devTEF_Audio_Set_Mute(uint16_t mode)
{
bool devTEF_Audio_Set_Mute(uint8_t mode) {
return devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Mute, 5, mode);
}
bool devTEF_APPL_Set_OperationMode(uint16_t mode)
{
bool devTEF_APPL_Set_OperationMode(bool mode) {
return devTEF_Set_Cmd(TEF_APPL, Cmd_Set_OperationMode, 5, mode);
}
bool devTEF_APPL_Get_Operation_Status (uint8_t *bootstatus)
{
bool devTEF_APPL_Set_StereoImprovement(bool mode) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_StereoImprovement, 5, mode);
}
bool devTEF_APPL_Set_StereoBandBlend_Time(uint16_t attack, uint16_t decay) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_StBandBlend_Time, 7, attack, decay);
}
bool devTEF_APPL_Set_StereoBandBlend_Gain(uint16_t band1, uint16_t band2, uint16_t band3, uint16_t band4) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_StBandBlend_Gain, 11, band1, band2, band3, band4);
}
bool devTEF_APPL_Set_StereoBandBlend_Bias(int16_t band1, int16_t band2, int16_t band3, int16_t band4) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_StBandBlend_Bias, 11, band1, band2, band3, band4);
}
bool devTEF_Radio_Set_Softmute_Max_FM(uint8_t mode) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Softmute_Max, 7, uint16_t(mode), uint16_t(200));
}
bool devTEF_Radio_Set_Softmute_Max_AM(uint8_t mode) {
return devTEF_Set_Cmd(TEF_AM, Cmd_Set_Softmute_Max, 7, uint16_t(mode), uint16_t(300));
}
bool devTEF_APPL_Get_Operation_Status (uint8_t *bootstatus) {
uint8_t buf[2];
uint16_t r = devTEF_Get_Cmd(TEF_APPL, Cmd_Get_Operation_Status, buf, sizeof(buf));
*bootstatus = Convert8bto16b(buf);
return r;
}
bool devTEF_Radio_Get_Quality_Status (int16_t *level, uint16_t *usn, uint16_t *wam, int16_t *offset, uint16_t *bandwidth, uint16_t *mod)
{
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;
}
bool devTEF_Radio_Get_Quality_Status (int16_t *level, uint16_t *usn, uint16_t *wam, int16_t *offset, uint16_t *bandwidth, uint16_t *mod) {
uint8_t buf[14];
uint16_t r = devTEF_Get_Cmd(TEF_FM, Cmd_Get_Quality_Status, buf, sizeof(buf));
uint16_t r = devTEF_Get_Cmd(TEF_FM, Cmd_Get_Quality_Data, buf, sizeof(buf));
*level = Convert8bto16b(buf + 2);
*usn = Convert8bto16b(buf + 4);
@@ -165,25 +215,23 @@ bool devTEF_Radio_Get_Quality_Status (int16_t *level, uint16_t *usn, uint16_t *w
return r;
}
bool devTEF_Radio_Get_Quality_Status_AM (int16_t *level, uint16_t *usn, uint16_t *wam, int16_t *offset, uint16_t *bandwidth, uint16_t *mod)
{
bool devTEF_Radio_Get_Quality_Status_AM (int16_t *level, uint16_t *noise, uint16_t *cochannel, int16_t *offset, uint16_t *bandwidth, uint16_t *mod) {
uint8_t buf[14];
uint16_t r = devTEF_Get_Cmd(TEF_AM, Cmd_Get_Quality_Status, buf, sizeof(buf));
uint16_t r = devTEF_Get_Cmd(TEF_AM, Cmd_Get_Quality_Data, buf, sizeof(buf));
*level = Convert8bto16b(buf + 2);
*usn = Convert8bto16b(buf + 4);
*wam = Convert8bto16b(buf + 6);
*noise = Convert8bto16b(buf + 4);
*cochannel = Convert8bto16b(buf + 6);
*offset = Convert8bto16b(buf + 8);
*bandwidth = Convert8bto16b(buf + 10) / 10;
*mod = Convert8bto16b(buf + 12) / 10;
return r;
}
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)
{
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) {
uint8_t buf[12];
uint8_t r = devTEF_Get_Cmd(TEF_FM, Cmd_Get_RDS_Status, buf, sizeof(buf));
*status = Convert8bto16b(buf);
*A_block = Convert8bto16b(buf + 2);
*B_block = Convert8bto16b(buf + 4);
@@ -193,8 +241,7 @@ bool devTEF_Radio_Get_RDS_Data (uint16_t *status, uint16_t *A_block, uint16_t *B
return r;
}
bool devTEF_Radio_Get_Stereo_Status(uint16_t *status)
{
bool devTEF_Radio_Get_Stereo_Status(uint16_t *status) {
uint8_t buf[2];
uint16_t r = devTEF_Get_Cmd(TEF_FM, Cmd_Get_Signal_Status, buf, sizeof(buf));
@@ -202,17 +249,7 @@ bool devTEF_Radio_Get_Stereo_Status(uint16_t *status)
return r;
}
bool devTEF_Radio_Set_RDS(bool fullsearchrds)
{
if (fullsearchrds == true) {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_RDS, 9, 3, 1, 0);
} else {
return devTEF_Set_Cmd(TEF_FM, Cmd_Set_RDS, 9, 1, 1, 0);
}
}
bool devTEF_Radio_Get_Identification (uint16_t *device, uint16_t *hw_version, uint16_t *sw_version)
{
bool devTEF_Radio_Get_Identification (uint16_t *device, uint16_t *hw_version, uint16_t *sw_version) {
uint8_t buf[6];
uint16_t r = devTEF_Get_Cmd(TEF_APPL, Cmd_Get_Identification, buf, sizeof(buf));
@@ -222,13 +259,12 @@ bool devTEF_Radio_Get_Identification (uint16_t *device, uint16_t *hw_version, ui
return r;
}
bool devTEF_Radio_Set_Wavegen(bool mode, int16_t amplitude, uint16_t freq)
{
bool devTEF_Radio_Set_Wavegen(bool mode, int16_t amplitude, uint16_t freq) {
if (mode == true) {
devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Input, 5, 240);
return devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_WaveGen, 15, 5, 0, amplitude*10, freq, amplitude*10 , freq);
devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Input, 5, 240);
return 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_Input, 5, 0);
return devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_WaveGen, 15, 0);
devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Input, 5, 0);
return devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_WaveGen, 15, 0);
}
}
}

142
src/Tuner_Drv_Lithio.h
View File

@@ -1,73 +1,103 @@
typedef enum
{ TEF_FM = 32,
TEF_AM = 33,
TEF_AUDIO = 48,
TEF_APPL = 64
typedef enum {
TEF_FM = 32,
TEF_AM = 33,
TEF_AUDIO = 48,
TEF_APPL = 64
} TEF_MODULE;
typedef enum
{ Cmd_Tune_To = 1,
Cmd_Set_Bandwidth = 10,
Cmd_Set_RFAGC = 11,
Cmd_Set_MphSuppression = 20,
Cmd_Set_ChannelEqualizer= 22,
Cmd_Set_Deemphasis = 31,
Cmd_Set_LevelOffset = 39,
Cmd_Set_Softmute_Max = 45,
Cmd_Set_Highcut_Level = 52,
Cmd_Set_Highcut_Noise = 53,
Cmd_Set_Highcut_Mph = 54,
Cmd_Set_Highcut_Max = 55,
Cmd_Set_Stereo_Level = 62,
Cmd_Set_Stereo_Noise = 63,
Cmd_Set_Stereo_Mph = 64,
Cmd_Set_Stereo_Min = 66,
Cmd_Set_RDS = 81,
Cmd_Get_Quality_Status = 128,
Cmd_Get_RDS_Status = 130,
Cmd_Get_Signal_Status = 133
typedef enum {
Cmd_Tune_To = 1,
Cmd_Set_Bandwidth = 10,
Cmd_Set_RFAGC = 11,
Cmd_Set_Antenna = 12,
Cmd_Set_CoChannelDet = 14,
Cmd_Set_MphSuppression = 20,
Cmd_Set_ChannelEqualizer = 22,
Cmd_Set_NoiseBlanker = 23,
Cmd_Set_NoiseBlanker_Audio = 24,
Cmd_Set_Deemphasis = 31,
Cmd_Set_StereoImprovement = 32,
Cmd_Set_LevelOffset = 39,
Cmd_Set_Softmute_Max = 45,
Cmd_Set_Highcut_Level = 52,
Cmd_Set_Highcut_Noise = 53,
Cmd_Set_Highcut_Mph = 54,
Cmd_Set_Highcut_Max = 55,
Cmd_Set_Stereo_Level = 62,
Cmd_Set_Stereo_Noise = 63,
Cmd_Set_Stereo_Mph = 64,
Cmd_Set_Stereo_Min = 66,
Cmd_Set_StHiBlend_Level = 72,
Cmd_Set_StHiBlend_Noise = 73,
Cmd_Set_StHiBlend_Mph = 74,
Cmd_Set_StHiBlend_Max = 75,
Cmd_Set_RDS = 81,
Cmd_Set_Specials = 85,
Cmd_Set_StBandBlend_Time = 90,
Cmd_Set_StBandBlend_Gain = 91,
Cmd_Set_StBandBlend_Bias = 92,
Cmd_Get_Quality_Status = 128,
Cmd_Get_Quality_Data = 129,
Cmd_Get_RDS_Status = 130,
Cmd_Get_Signal_Status = 133,
Cmd_Get_Processing_Status = 134
} TEF_RADIO_COMMAND;
typedef enum
{ Cmd_Set_Volume = 10,
Cmd_Set_Mute = 11,
Cmd_Set_Input = 12,
Cmd_Set_WaveGen = 24
typedef enum {
Cmd_Set_Volume = 10,
Cmd_Set_Mute = 11,
Cmd_Set_Input = 12,
Cmd_Set_WaveGen = 24
} TEF_AUDIO_COMMAND;
typedef enum
{
Cmd_Set_OperationMode = 1,
Cmd_Get_Operation_Status = 128,
Cmd_Get_Identification = 130
typedef enum {
Cmd_Set_OperationMode = 1,
Cmd_Get_Operation_Status = 128,
Cmd_Get_Identification = 130
} TEF_APPL_COMMAND;
bool devTEF_Radio_Set_RDS(bool fullsearchrds);
bool devTEF_Radio_Set_Softmute_Max_FM(uint8_t mode);
bool devTEF_Radio_Set_Softmute_Max_AM(uint8_t mode);
bool devTEF_Set_Cmd(TEF_MODULE module, uint8_t cmd, uint16_t len, ...);
bool devTEF_Radio_Tune_To (uint16_t frequency);
bool devTEF_Radio_Tune_To_AM (uint16_t frequency);
bool devTEF_Radio_Get_Identification (uint16_t *device, uint16_t *hw_version, uint16_t *sw_version);
bool devTEF_Radio_Tune_To (uint16_t frequency );
bool devTEF_Radio_Tune_AM (uint16_t frequency );
bool devTEF_Radio_Get_Quality_Status (int16_t *level, uint16_t *usn, uint16_t *wam, int16_t *offset, uint16_t *bandwidth, uint16_t *mod);
bool devTEF_Radio_Get_Quality_Status_AM (int16_t *level, uint16_t *usn, uint16_t *wam, int16_t *offset, uint16_t *bandwidth, uint16_t *mod);
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);
bool devTEF_Radio_Get_Quality_Status_AM (int16_t *level, uint16_t *noise, uint16_t *cochannel, int16_t *offset, uint16_t *bandwidth, uint16_t *mod);
bool devTEF_APPL_Get_Operation_Status(uint8_t *bootstatus);
bool devTEF_Audio_Set_Mute(uint16_t mode);
bool devTEF_Audio_Set_Mute(uint8_t mode);
bool devTEF_Audio_Set_Volume(int16_t volume);
bool devTEF_Radio_Get_Stereo_Status(uint16_t *status);
bool devTEF_APPL_Set_OperationMode(uint16_t mode);
bool devTEF_APPL_Set_OperationMode(bool mode);
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);
bool devTEF_Radio_Set_Bandwidth(uint16_t mode, uint16_t bandwidth, uint16_t control_sensitivity, uint16_t low_level_sensitivity);
bool devTEF_Radio_Set_Bandwidth_AM(uint16_t mode, uint16_t bandwidth, uint16_t control_sensitivity, uint16_t low_level_sensitivity);
bool devTEF_Radio_Set_Bandwidth(uint8_t mode, uint16_t bandwidth, uint16_t control_sensitivity, uint16_t low_level_sensitivity);
bool devTEF_Radio_Set_BandwidthAM(uint8_t mode, uint16_t bandwidth, uint16_t control_sensitivity, uint16_t low_level_sensitivity);
bool devTEF_Radio_Set_Noiseblanker_AM(uint8_t mode, uint16_t start);
bool devTEF_Radio_Set_Attenuator_AM(uint16_t start);
bool devTEF_Radio_Set_CoChannel_AM(uint16_t start);
bool devTEF_Radio_Set_LevelOffset(int16_t offset);
bool devTEF_Radio_Set_Stereo_Level(uint16_t mode, uint16_t start, uint16_t slope);
bool devTEF_Radio_Set_Stereo_Noise(uint16_t mode, uint16_t start, uint16_t slope);
bool devTEF_Radio_Set_Stereo_Mph(uint16_t mode, uint16_t start, uint16_t slope);
bool devTEF_Radio_Set_Stereo_Min(uint16_t mode);
bool devTEF_Radio_Set_MphSuppression(uint16_t mph);
bool devTEF_Radio_Set_ChannelEqualizer(uint16_t eq);
bool devTEF_Radio_Set_RFAGC(uint16_t start);
bool devTEF_Radio_Set_Stereo_Level(uint8_t mode, uint16_t start, uint16_t slope);
bool devTEF_Radio_Set_Stereo_Noise(uint8_t mode, uint16_t start, uint16_t slope);
bool devTEF_Radio_Set_Stereo_Mph(uint8_t mode, uint16_t start, uint16_t slope);
bool devTEF_Radio_Set_Stereo_Min(bool mode);
bool devTEF_Radio_Set_MphSuppression(bool mph);
bool devTEF_Radio_Set_ChannelEqualizer(bool eq);
bool devTEF_Radio_Set_RFAGC(uint16_t agc);
bool devTEF_Radio_Set_Deemphasis(uint16_t timeconstant);
bool devTEF_Radio_Set_Highcut_Max(uint16_t mode, uint16_t limit);
bool devTEF_Radio_Set_Highcut_Level(uint16_t mode, uint16_t start, uint16_t slope);
bool devTEF_Radio_Set_Highcut_Noise(uint16_t mode, uint16_t start, uint16_t slope);
bool devTEF_Radio_Set_Highcut_Mph(uint16_t mode, uint16_t start, uint16_t slope);
bool devTEF_Radio_Set_RDS(bool fullsearchrds);
bool devTEF_Radio_Set_Wavegen(bool mode, int16_t amplitude, uint16_t freq);
bool devTEF_Radio_Specials(uint16_t audio);
bool devTEF_APPL_Set_StereoImprovement(bool mode);
bool devTEF_APPL_Set_StereoBandBlend_Time(uint16_t attack, uint16_t decay);
bool devTEF_APPL_Set_StereoBandBlend_Gain(uint16_t band1, uint16_t band2, uint16_t band3, uint16_t band4);
bool devTEF_APPL_Set_StereoBandBlend_Bias(int16_t band1, int16_t band2, int16_t band3, int16_t band4);
bool devTEF_Radio_Set_Highcut_Max(uint8_t mode, uint16_t limit);
bool devTEF_Radio_Set_Highcut_Level(uint8_t mode, uint16_t start, uint16_t slope);
bool devTEF_Radio_Set_Highcut_Noise(uint8_t mode, uint16_t start, uint16_t slope);
bool devTEF_Radio_Set_Highcut_Mph(uint8_t mode, uint16_t start, uint16_t slope);
bool devTEF_Radio_Set_StHiBlend_Max(uint8_t mode, uint16_t limit);
bool devTEF_Radio_Set_StHiBlend_Level(uint8_t mode, uint16_t start, uint16_t slope);
bool devTEF_Radio_Set_StHiBlend_Noise(uint8_t mode, uint16_t start, uint16_t slope);
bool devTEF_Radio_Set_StHiBlend_Mph(uint8_t mode, uint16_t start, uint16_t slope);
bool devTEF_Radio_Set_NoisBlanker(uint8_t mode, uint16_t start);
bool devTEF_Radio_Set_Wavegen(bool mode, int16_t amplitude, uint16_t freq);

109
src/Tuner_Interface.cpp
View File

@@ -4,9 +4,6 @@
#include "Tuner_Patch_Lithio_V205_p512.h"
#include <Wire.h>
bool debug_tx = false;
bool debug_rx = false;
static const unsigned char tuner_init_tab[] = {
7, 0x20, 0x0B, 0x01, 0x03, 0x98, 0x00, 0x00,
5, 0x20, 0x14, 0x01, 0x00, 0x00,
@@ -52,51 +49,24 @@ static const unsigned char tuner_init_tab9216[] = {
2, 0xff, 100,
};
bool Tuner_WriteBuffer(unsigned char *buf, uint16_t len)
{
bool Tuner_WriteBuffer(unsigned char *buf, uint16_t len) {
Wire.beginTransmission(0x64);
if (debug_tx == true) {
Serial.println();
}
for (uint16_t i = 0; i < len; i++) {
if (debug_tx == true) {
if (buf[i] < 0x10) {
Serial.print("0");
}
Serial.print(buf[i], HEX);
Serial.print(" ");
}
Wire.write(buf[i]);
}
for (uint16_t i = 0; i < len; i++) Wire.write(buf[i]);
uint8_t r = Wire.endTransmission();
delay(2);
return (r == 0) ? 1 : 0;
}
bool Tuner_ReadBuffer(unsigned char *buf, uint16_t len)
{
bool Tuner_ReadBuffer(unsigned char *buf, uint16_t len) {
Wire.requestFrom(0x64, len);
if (debug_rx == true) {
Serial.println();
}
if (Wire.available() == len) {
for (uint16_t i = 0; i < len; i++) {
if (debug_rx == true) {
if (buf[i] < 0x10) {
Serial.print("0");
}
Serial.print(buf[i], HEX);
Serial.print(" ");
}
buf[i] = Wire.read();
}
for (uint16_t i = 0; i < len; i++) buf[i] = Wire.read();
return 1;
}
return 0;
}
bool Tuner_Patch_Load(const unsigned char *pLutBytes, uint16_t size)
{
bool Tuner_Patch_Load(const unsigned char *pLutBytes, uint16_t size) {
unsigned char buf[24 + 1];
uint16_t i, len;
uint16_t r;
@@ -107,24 +77,17 @@ bool Tuner_Patch_Load(const unsigned char *pLutBytes, uint16_t size)
len = (size > 24) ? 24 : size;
size -= len;
for (i = 0; i < len; i++)
buf[1 + i] = pLutBytes[i];
for (i = 0; i < len; i++) buf[1 + i] = pLutBytes[i];
pLutBytes += len;
if (1 != (r = Tuner_WriteBuffer(buf, len + 1)))
{
break;
}
if (1 != (r = Tuner_WriteBuffer(buf, len + 1))) break;
}
return r;
}
bool Tuner_Table_Write(const unsigned char *tab)
{
if (tab[1] == 0xff)
{
bool Tuner_Table_Write(const unsigned char *tab) {
if (tab[1] == 0xff) {
delay(tab[2]);
return 1;
} else {
@@ -152,12 +115,18 @@ void Tuner_Patch(byte TEF) {
Wire.write(0x00);
Wire.write(0x74);
Wire.endTransmission();
if (TEF == 101) {
Tuner_Patch_Load(pPatchBytes101, PatchSize101);
} else if (TEF == 102) {
Tuner_Patch_Load(pPatchBytes102, PatchSize102);
} else if (TEF == 205) {
Tuner_Patch_Load(pPatchBytes205, PatchSize205);
switch (TEF) {
case 101:
Tuner_Patch_Load(pPatchBytes101, PatchSize101);
break;
case 102:
Tuner_Patch_Load(pPatchBytes102, PatchSize102);
break;
case 205:
Tuner_Patch_Load(pPatchBytes205, PatchSize205);
break;
}
Wire.beginTransmission(0x64);
Wire.write(0x1c);
@@ -170,12 +139,18 @@ void Tuner_Patch(byte TEF) {
Wire.write(0x00);
Wire.write(0x75);
Wire.endTransmission();
if (TEF == 101) {
Tuner_Patch_Load(pLutBytes101, LutSize101);
} else if (TEF == 102) {
Tuner_Patch_Load(pLutBytes102, LutSize102);
} else if (TEF == 205) {
Tuner_Patch_Load(pLutBytes205, LutSize205);
switch (TEF) {
case 101:
Tuner_Patch_Load(pLutBytes101, LutSize101);
break;
case 102:
Tuner_Patch_Load(pLutBytes102, LutSize102);
break;
case 205:
Tuner_Patch_Load(pLutBytes205, LutSize205);
break;
}
Wire.beginTransmission(0x64);
Wire.write(0x1c);
@@ -193,10 +168,8 @@ bool Tuner_Init(void) {
uint16_t r;
const unsigned char *p = tuner_init_tab;
for (uint16_t i = 0; i < sizeof(tuner_init_tab); i += (p[i] + 1))
{
if (1 != (r = Tuner_Table_Write(p + i)))
break;
for (uint16_t i = 0; i < sizeof(tuner_init_tab); i += (p[i] + 1)) {
if (1 != (r = Tuner_Table_Write(p + i))) break;
}
return r;
}
@@ -205,10 +178,8 @@ bool Tuner_Init4000(void) {
uint16_t r;
const unsigned char *p = tuner_init_tab4000;
for (uint16_t i = 0; i < sizeof(tuner_init_tab4000); i += (p[i] + 1))
{
if (1 != (r = Tuner_Table_Write(p + i)))
break;
for (uint16_t i = 0; i < sizeof(tuner_init_tab4000); i += (p[i] + 1)) {
if (1 != (r = Tuner_Table_Write(p + i))) break;
}
return r;
}
@@ -217,10 +188,8 @@ bool Tuner_Init9216(void) {
uint16_t r;
const unsigned char *p = tuner_init_tab9216;
for (uint16_t i = 0; i < sizeof(tuner_init_tab9216); i += (p[i] + 1))
{
if (1 != (r = Tuner_Table_Write(p + i)))
break;
for (uint16_t i = 0; i < sizeof(tuner_init_tab9216); i += (p[i] + 1)) {
if (1 != (r = Tuner_Table_Write(p + i))) break;
}
return r;
}

6
src/Tuner_Patch_Lithio_V101_p119.h
View File

@@ -1,7 +1,6 @@
extern const size_t PatchSize101;
extern const unsigned char *pPatchBytes101;
static const unsigned char PatchByteValues101[] =
{
static const unsigned char PatchByteValues101[] = {
0xF0, 0x00, 0x38, 0x40, 0xD0, 0x80, 0x32, 0x81, 0x38, 0x58, 0xD0, 0x80, 0xF0, 0x00, 0x38, 0x52, 0xD0, 0x80, 0xF0, 0x00, 0x38, 0x64, 0xD0, 0x80,
0xC4, 0xCB, 0x38, 0x68, 0xD0, 0x80, 0x80, 0x20, 0x38, 0xA9, 0xD0, 0x80, 0x90, 0x41, 0x38, 0xAE, 0xD0, 0x80, 0xF0, 0x00, 0x38, 0xB7, 0xD0, 0x80,
0x80, 0x08, 0x38, 0xD8, 0xD0, 0x80, 0xF0, 0x00, 0x39, 0x2D, 0xD0, 0x80, 0xF0, 0x00, 0x3B, 0x55, 0xD0, 0x80, 0xF0, 0x00, 0x3B, 0x57, 0xD0, 0x80,
@@ -252,8 +251,7 @@ const unsigned char * pPatchBytes101 = &PatchByteValues101[0];
extern const size_t LutSize101;
extern const unsigned char * pLutBytes101;
static unsigned char LutByteValues101[] =
{
static unsigned char LutByteValues101[] = {
0x40, 0x13, 0x46, 0xEA, 0x47, 0x07, 0x48, 0x2E,
0x48, 0x4D, 0x4C, 0x45, 0x4D, 0x20, 0x4F, 0x78,
0x50, 0x33, 0x53, 0xC7, 0x54, 0x0F, 0x54, 0x10,

6
src/Tuner_Patch_Lithio_V102_p224.h
View File

@@ -1,7 +1,6 @@
extern const size_t PatchSize102;
extern const unsigned char *pPatchBytes102;
static const unsigned char PatchByteValues102[] =
{
static const unsigned char PatchByteValues102[] = {
0xF0, 0x00, 0x38, 0x3B, 0xD0, 0x80, 0xF0, 0x00, 0x38, 0x43, 0xD0, 0x80, 0x43, 0xB2, 0x38, 0x46, 0xD0, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xC2, 0xF7,
0xF0, 0x00, 0x38, 0x77, 0xD0, 0x80, 0xF0, 0x00, 0x38, 0x7B, 0xDF, 0x80, 0x80, 0xFC, 0x39, 0x0E, 0xD0, 0x80, 0xC2, 0x38, 0x20, 0x11, 0x40, 0xB7,
0x9F, 0xA7, 0x39, 0x13, 0xD2, 0x80, 0x9F, 0xA7, 0x39, 0x1D, 0xD2, 0x80, 0xF0, 0x00, 0x39, 0x24, 0xD0, 0x80, 0xF0, 0x00, 0x39, 0x27, 0xD0, 0x80,
@@ -264,8 +263,7 @@ const unsigned char * pPatchBytes102 = &PatchByteValues102[0];
extern const size_t LutSize102;
extern const unsigned char * pLutBytes102;
static unsigned char LutByteValues102[] =
{
static unsigned char LutByteValues102[] = {
0x40, 0x13, 0x40, 0x2F, 0x41, 0x68, 0x41, 0xC1,
0x42, 0x14, 0x42, 0xA6, 0x44, 0xDE, 0x44, 0xE9,
0x45, 0xFB, 0x46, 0x11, 0x47, 0xC5, 0x47, 0xFC,

26
src/Tuner_Patch_Lithio_V205_p512.h
View File

@@ -1,7 +1,6 @@
extern const size_t PatchSize205;
extern const unsigned char *pPatchBytes205;
static const unsigned char PatchByteValues205[] =
{
static const unsigned char PatchByteValues205[] = {
0xF0, 0x00, 0x60, 0x40, 0xD0, 0x80, 0x20, 0x87, 0x60, 0x4C, 0xD0, 0x80, 0x90, 0x00, 0x60, 0x4E, 0xD0, 0x80, 0x22, 0x02, 0x00, 0x55, 0x60, 0x04,
0xF0, 0x00, 0x60, 0x65, 0xDF, 0x80, 0xF0, 0x00, 0x05, 0xBA, 0x60, 0x0E, 0x20, 0x90, 0x60, 0x9B, 0xD0, 0x80, 0x31, 0x40, 0x60, 0x9F, 0xD0, 0x80,
0x9E, 0xB9, 0x60, 0xAD, 0xD0, 0x80, 0xF0, 0x00, 0x60, 0xAF, 0xD0, 0x80, 0x20, 0x15, 0x60, 0xB3, 0xD2, 0x80, 0xF0, 0x00, 0x60, 0xCE, 0xD0, 0x80,
@@ -249,23 +248,12 @@ const unsigned char * pPatchBytes205 = &PatchByteValues205[0];
extern const size_t LutSize205;
extern const unsigned char * pLutBytes205;
static unsigned char LutByteValues205[] =
{
0x80, 0x17, 0x80, 0x45, 0x80, 0x96, 0x81, 0x5B,
0x82, 0xD6, 0x83, 0x76, 0x88, 0x0B, 0x88, 0x10,
0x88, 0xDB, 0x89, 0x48, 0x89, 0xE9, 0x8B, 0x0A,
0x8B, 0x12, 0x8B, 0x13, 0x8B, 0x21, 0x8B, 0x26,
0x8C, 0x6F, 0x8F, 0x91, 0x8F, 0xF6, 0x94, 0xD0,
0x95, 0x20, 0x95, 0x33, 0x95, 0x6F, 0x95, 0xA8,
0x95, 0xAC, 0x95, 0xC3, 0x95, 0xE1, 0x97, 0xC9,
0x97, 0xF6, 0x98, 0x8D, 0x99, 0x00, 0x9A, 0x00,
0x9E, 0x73, 0xA0, 0x12, 0xA1, 0x03, 0xA1, 0x68,
0xA2, 0xF0, 0xA3, 0x0D, 0xA3, 0x4C, 0xA3, 0x52,
0xA3, 0xED, 0xA5, 0x20, 0xA5, 0x25, 0xA6, 0x0F,
0xA6, 0x1D, 0xA8, 0x31, 0xAB, 0x01, 0xAB, 0x1F,
0xAB, 0x4C, 0xAC, 0x76, 0xAC, 0x88, 0xAC, 0x97,
0xAD, 0xB0, 0xAD, 0xB7, 0xAD, 0xB8, 0xB0, 0x55,
0xB0, 0xC6, 0xB0, 0xE2, 0xB1, 0x01, 0xB1, 0x0B,
static unsigned char LutByteValues205[] = {
0x80, 0x17, 0x80, 0x45, 0x80, 0x96, 0x81, 0x5B, 0x82, 0xD6, 0x83, 0x76, 0x88, 0x0B, 0x88, 0x10, 0x88, 0xDB, 0x89, 0x48, 0x89, 0xE9, 0x8B, 0x0A,
0x8B, 0x12, 0x8B, 0x13, 0x8B, 0x21, 0x8B, 0x26, 0x8C, 0x6F, 0x8F, 0x91, 0x8F, 0xF6, 0x94, 0xD0, 0x95, 0x20, 0x95, 0x33, 0x95, 0x6F, 0x95, 0xA8,
0x95, 0xAC, 0x95, 0xC3, 0x95, 0xE1, 0x97, 0xC9, 0x97, 0xF6, 0x98, 0x8D, 0x99, 0x00, 0x9A, 0x00, 0x9E, 0x73, 0xA0, 0x12, 0xA1, 0x03, 0xA1, 0x68,
0xA2, 0xF0, 0xA3, 0x0D, 0xA3, 0x4C, 0xA3, 0x52, 0xA3, 0xED, 0xA5, 0x20, 0xA5, 0x25, 0xA6, 0x0F, 0xA6, 0x1D, 0xA8, 0x31, 0xAB, 0x01, 0xAB, 0x1F,
0xAB, 0x4C, 0xAC, 0x76, 0xAC, 0x88, 0xAC, 0x97, 0xAD, 0xB0, 0xAD, 0xB7, 0xAD, 0xB8, 0xB0, 0x55, 0xB0, 0xC6, 0xB0, 0xE2, 0xB1, 0x01, 0xB1, 0x0B,
0xB1, 0x35, 0xB1, 0x3B, 0xB1, 0x97, 0xB3, 0x03
};