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
src/TEF6686.cpp
+305 -132
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);
}
src/TEF6686.h
+66 -34
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;
src/Tuner_Api.cpp
-106
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;
}
src/Tuner_Api.h
-7
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);
src/Tuner_Drv_Lithio.cpp
+123 -87
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);
}
}
}
src/Tuner_Drv_Lithio.h
+86 -56
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);
src/Tuner_Interface.cpp
+39 -70
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;
}
src/Tuner_Patch_Lithio_V101_p119.h
+2 -4
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,
src/Tuner_Patch_Lithio_V102_p224.h
+2 -4
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,
src/Tuner_Patch_Lithio_V205_p512.h
+7 -19
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
};