You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1118 lines
21 KiB
C++
1118 lines
21 KiB
C++
#include "ckeystonecomm.h"
|
|
|
|
#ifdef QT_DEBUG
|
|
//#define OUTPUT_DEBUG
|
|
#endif
|
|
|
|
#ifdef Q_OS_WIN
|
|
#include <windows.h>
|
|
#endif
|
|
#include <QDebug>
|
|
#include <QThread>
|
|
|
|
#define HEAD 0xFE
|
|
#define END 0xFD
|
|
|
|
// Set GPIO function
|
|
#define DATA_IN 0
|
|
#define DATA_OUT 1
|
|
#define MUTE 2
|
|
#define I2S_DATA_IN 3
|
|
#define I2S_LRCLK_IN 4
|
|
#define I2S_SSCLK_IN 5
|
|
#define I2S_BCLK_IN 6
|
|
#define I2S_DATA_OUT 7
|
|
#define I2S_LRCLK_OUT 8
|
|
#define I2S_SSCLK_OUT 9
|
|
#define I2S_BCLK_OUT 10
|
|
#define SPDIF_OUT 11
|
|
#define SPI_DO 12
|
|
#define SPI_CLK 13
|
|
#define SPI_CS 14
|
|
#define SPI_DI 15
|
|
|
|
// Driving strength(0~3)
|
|
#define DRIVE_2MA 0
|
|
#define DRIVE_4MA 1
|
|
#define DRIVE_6MA 2
|
|
#define DRIVE_8MA 3
|
|
|
|
#define ANTENNA_RELAY_PIN 11
|
|
|
|
QString programTypeText[] =
|
|
{
|
|
"",
|
|
"News",
|
|
"Current Affairs",
|
|
"Information",
|
|
"Sport",
|
|
"Education",
|
|
"Drama",
|
|
"Arts",
|
|
"Science",
|
|
"Talk",
|
|
"Pop Music",
|
|
"Rock Music",
|
|
"Easy Listening",
|
|
"Light Classical",
|
|
"Classical Music",
|
|
"Other Music",
|
|
"Weather",
|
|
"Finance",
|
|
"Children",
|
|
"Factual",
|
|
"Religion",
|
|
"Phone In",
|
|
"Travel",
|
|
"Leisure",
|
|
"Jazz and Blues",
|
|
"Country Music",
|
|
"National Music",
|
|
"Oldies Music",
|
|
"Folk Music",
|
|
"Documentary",
|
|
"Undefined",
|
|
"Undefined"
|
|
};
|
|
|
|
cKeyStoneCOMM::cKeyStoneCOMM(const QString& commPort, QObject *parent) :
|
|
QObject{parent},
|
|
m_commPort{commPort},
|
|
m_serialPort{nullptr},
|
|
m_serialReadError{false},
|
|
m_hardMute{false},
|
|
m_initialized{false},
|
|
m_totalProgram{0},
|
|
m_currentProgram{0},
|
|
m_mutePrevVolume{0},
|
|
m_mainTransportID{0},
|
|
m_MSCDataIndex{0},
|
|
m_imageDataIndex{0}
|
|
{
|
|
}
|
|
|
|
cKeyStoneCOMM::~cKeyStoneCOMM()
|
|
{
|
|
close();
|
|
}
|
|
|
|
bool cKeyStoneCOMM::open(bool _hardMute)
|
|
{
|
|
close();
|
|
|
|
m_hardMute = _hardMute;
|
|
m_serialPort = new QSerialPort(m_commPort, this);
|
|
if(!m_serialPort)
|
|
return(false);
|
|
|
|
m_serialPort->setBaudRate(QSerialPort::Baud115200);
|
|
m_serialPort->setDataBits(QSerialPort::Data8);
|
|
m_serialPort->setStopBits(QSerialPort::OneStop);
|
|
m_serialPort->setParity(QSerialPort::NoParity);
|
|
m_serialPort->setFlowControl(QSerialPort::NoFlowControl);
|
|
|
|
if(!m_serialPort->open(QIODevice::ReadWrite))
|
|
{
|
|
qDebug() << "open failed: " << m_serialPort->errorString();
|
|
close();
|
|
return(false);
|
|
}
|
|
#ifdef OUTPUT_DEBUG
|
|
qDebug() << "open succeeded.";
|
|
#endif
|
|
|
|
m_serialPort->setBaudRate(QSerialPort::Baud115200);
|
|
m_serialPort->setDataBits(QSerialPort::Data8);
|
|
m_serialPort->setStopBits(QSerialPort::OneStop);
|
|
m_serialPort->setParity(QSerialPort::NoParity);
|
|
m_serialPort->setFlowControl(QSerialPort::NoFlowControl);
|
|
|
|
#ifdef OUTPUT_DEBUG
|
|
qDebug() << "*** Baud Rate: " << m_serialPort->baudRate();
|
|
qDebug() << "*** Data Bits: " << m_serialPort->dataBits();
|
|
qDebug() << "*** Stop Bits: " << m_serialPort->stopBits();
|
|
qDebug() << "*** Parity Bits: " << m_serialPort->parity();
|
|
qDebug() << "*** Flow Control: " << m_serialPort->flowControl();
|
|
#endif
|
|
|
|
connect(m_serialPort, &QSerialPort::readyRead, this, &cKeyStoneCOMM::serialReadReady);
|
|
connect(m_serialPort, &QSerialPort::errorOccurred, this, &cKeyStoneCOMM::serialReadError);
|
|
|
|
if(m_hardMute)
|
|
hardMute();
|
|
else
|
|
hardUnmute();
|
|
|
|
QThread::msleep(800);
|
|
|
|
if(!isSysReady())
|
|
{
|
|
for(int i = 0;i < 2;i++)
|
|
{
|
|
if(hardResetRadio())
|
|
{
|
|
for(int x = 0;x < 2;x++)
|
|
{
|
|
if(isSysReady())
|
|
{
|
|
// Enable Pin 11 for antenna switching
|
|
GPIO_SetFunction(ANTENNA_RELAY_PIN, DATA_OUT, DRIVE_8MA);
|
|
m_totalProgram = getTotalProgram();
|
|
m_initialized = true;
|
|
qDebug() << "Initialized. Current programs: " << m_totalProgram;
|
|
return(true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return(false);
|
|
}
|
|
else
|
|
{
|
|
// Enable Pin 11 for antenna switching
|
|
GPIO_SetFunction(ANTENNA_RELAY_PIN, DATA_OUT, DRIVE_8MA);
|
|
m_totalProgram = getTotalProgram();
|
|
}
|
|
|
|
m_initialized = true;
|
|
|
|
#ifdef OUTPUT_DEBUG
|
|
qDebug() << "Initialized. Current programs: " << m_totalProgram;
|
|
#endif
|
|
|
|
return(true);
|
|
}
|
|
|
|
void cKeyStoneCOMM::close()
|
|
{
|
|
if(m_serialPort)
|
|
{
|
|
if(m_serialPort->isOpen())
|
|
{
|
|
stopStream();
|
|
m_serialPort->close();
|
|
}
|
|
delete m_serialPort;
|
|
m_serialPort = nullptr;
|
|
}
|
|
m_initialized = false;
|
|
}
|
|
|
|
int16_t cKeyStoneCOMM::channelCount()
|
|
{
|
|
return(m_totalProgram);
|
|
}
|
|
|
|
bool cKeyStoneCOMM::setVolume(int8_t volume)
|
|
{
|
|
uint16_t dwBytes;
|
|
unsigned char output[] = {HEAD,0x01,0x22,0x01,0x00,0x01,0x00,END};
|
|
unsigned char input[8] = {0};
|
|
|
|
if((volume < 0) || (volume > 16))
|
|
return(false); // Volume out of range
|
|
|
|
output[6] = volume;
|
|
|
|
if(volume == 0)
|
|
if(m_hardMute)
|
|
hardMute();
|
|
|
|
if(!writeSerialBytes(output, 8, &dwBytes))
|
|
return(false);
|
|
|
|
if(dwBytes != 8)
|
|
return(false);
|
|
|
|
// need to check the return
|
|
if(!readSerialBytes(input, &dwBytes))
|
|
return(false);
|
|
|
|
m_currentVolume = volume;
|
|
|
|
return(true);
|
|
}
|
|
|
|
bool cKeyStoneCOMM::startStream(STREAM_MODE mode, uint16_t channel)
|
|
{
|
|
uint16_t dwBytes;
|
|
unsigned char input[8] = {0};
|
|
unsigned char output[] = {HEAD,0x01,0x00,0x01,0x00,0x05,0x00,0x00,0x00,0x00,0x00,END};
|
|
unsigned char strChannel[4];
|
|
|
|
if(mode == 0)
|
|
if(m_hardMute)
|
|
hardMute();
|
|
|
|
if((mode < 0) || (mode > 1))
|
|
return(false);
|
|
|
|
output[6] = mode;
|
|
|
|
if(mode == 0)
|
|
{
|
|
//DAB GPIO 11 set to LOW for antenna switching
|
|
GPIO_SetLevel(ANTENNA_RELAY_PIN, 0);
|
|
output[10] = (unsigned char)channel; // WARNING - This is not very safe, TODO
|
|
}
|
|
else
|
|
{
|
|
//FM GPIO 11 set to HIGH for antenna switching
|
|
GPIO_SetLevel(ANTENNA_RELAY_PIN, 1);
|
|
if(channel < 20000)
|
|
{
|
|
memcpy(&strChannel[0], &channel, sizeof(long));
|
|
output[7] = strChannel[3];
|
|
output[8] = strChannel[2];
|
|
output[9] = strChannel[1];
|
|
output[10] = strChannel[0];
|
|
}
|
|
else
|
|
return(false);
|
|
}
|
|
|
|
if(!writeSerialBytes(output, 12, &dwBytes))
|
|
return(false);
|
|
|
|
if(dwBytes != 12)
|
|
return(false);
|
|
|
|
// need to check the return
|
|
if(!readSerialBytes(input, &dwBytes))
|
|
return(false);
|
|
|
|
m_currentProgram = channel;
|
|
m_currentMode = mode;
|
|
|
|
return(true);
|
|
}
|
|
|
|
int16_t cKeyStoneCOMM::channel()
|
|
{
|
|
return(m_currentProgram);
|
|
}
|
|
|
|
bool cKeyStoneCOMM::stopStream()
|
|
{
|
|
uint16_t dwBytes;
|
|
unsigned char output[] = {HEAD,0x01,0x02,0x01,0x00,0x00,END};
|
|
unsigned char input[8] = {0};
|
|
|
|
if(m_hardMute)
|
|
hardMute();
|
|
|
|
if(!writeSerialBytes(output, 7, &dwBytes))
|
|
return(false);
|
|
|
|
if(dwBytes != 7)
|
|
return(false);
|
|
|
|
if(!readSerialBytes(input, &dwBytes))
|
|
return(false);
|
|
|
|
if(goodHeader(input, dwBytes))
|
|
{
|
|
if(input[2] == 0x01)
|
|
return(true);
|
|
else
|
|
return(false);
|
|
}
|
|
else
|
|
return(false);
|
|
}
|
|
|
|
bool cKeyStoneCOMM::nextStream()
|
|
{
|
|
long channel = 0;
|
|
char currentMode = playMode();
|
|
|
|
if(currentMode == STREAM_MODE_DAB)
|
|
{
|
|
channel = playIndex();
|
|
if(channel < m_totalProgram-1)
|
|
channel++;
|
|
else
|
|
channel = 0;
|
|
|
|
startStream(STREAM_MODE_DAB, channel);
|
|
return(true);
|
|
}
|
|
|
|
if(currentMode == STREAM_MODE_FM)
|
|
{
|
|
//HERWIG FMSearch(1);
|
|
return(true);
|
|
|
|
}
|
|
return(false);
|
|
}
|
|
|
|
bool cKeyStoneCOMM::prevStream()
|
|
{
|
|
long channel = 0;
|
|
char currentMode = playMode();
|
|
|
|
if(currentMode == STREAM_MODE_DAB)
|
|
{
|
|
channel = playIndex();
|
|
if(channel > 0)
|
|
channel--;
|
|
else
|
|
channel = m_totalProgram-1;
|
|
|
|
startStream(STREAM_MODE_DAB, channel);
|
|
return(true);
|
|
}
|
|
|
|
if(currentMode == STREAM_MODE_FM)
|
|
{
|
|
//HERWIG FMSearch(0);
|
|
return(true);
|
|
|
|
}
|
|
return(false);
|
|
}
|
|
|
|
cKeyStoneCOMM::STREAM_MODE cKeyStoneCOMM::playMode()
|
|
{
|
|
uint16_t dwBytes;
|
|
unsigned char input[8] = {0};
|
|
unsigned char output[] = {HEAD,0x01,0x11,0x01,0x00,0x00,END};
|
|
|
|
if(!writeSerialBytes(output, 7, &dwBytes))
|
|
return(STREAM_MODE_NONE);
|
|
|
|
if(dwBytes != 7)
|
|
return(STREAM_MODE_NONE);
|
|
|
|
if(!readSerialBytes(input, &dwBytes))
|
|
return(STREAM_MODE_NONE);
|
|
|
|
if(!goodHeader(input, dwBytes))
|
|
return(STREAM_MODE_NONE);
|
|
else
|
|
{
|
|
if((input[1] == 0x01) && (input[2] == 0x11))
|
|
return((STREAM_MODE)input[6]);
|
|
else
|
|
return(STREAM_MODE_NONE);
|
|
}
|
|
}
|
|
|
|
int16_t cKeyStoneCOMM::playIndex()
|
|
{
|
|
uint16_t dwBytes;
|
|
unsigned char output[] = {HEAD,0x01,0x12,0x01,0x00,0x00,END};
|
|
unsigned char input[11] = {0};
|
|
|
|
if(!writeSerialBytes(output, 7, &dwBytes))
|
|
return(-1);
|
|
|
|
if(!readSerialBytes(input, &dwBytes))
|
|
return(-1);
|
|
else
|
|
{
|
|
if(goodHeader(input, dwBytes))
|
|
{
|
|
long channel = (0xFF & input[6]) << 24 | (0xFF & input[7]) << 16 | (0xFF & input[8]) << 8 | (0xFF & input[9]);
|
|
return(channel);
|
|
|
|
}
|
|
else
|
|
return(-1);
|
|
}
|
|
}
|
|
|
|
int8_t cKeyStoneCOMM::volumePlus()
|
|
{
|
|
char currentVolume = volume();
|
|
if(currentVolume < 16)
|
|
currentVolume++;
|
|
|
|
if(setVolume(currentVolume))
|
|
return(currentVolume);
|
|
else
|
|
return(-1);
|
|
}
|
|
|
|
int8_t cKeyStoneCOMM::volumeMinus()
|
|
{
|
|
char currentVolume = volume();
|
|
if(currentVolume > 0)
|
|
currentVolume--;
|
|
|
|
if(setVolume(currentVolume))
|
|
return(currentVolume);
|
|
else
|
|
return(-1);
|
|
}
|
|
|
|
void cKeyStoneCOMM::volumeMute()
|
|
{
|
|
char currentVolume = volume();
|
|
if(currentVolume == 0)
|
|
setVolume(m_mutePrevVolume);
|
|
else
|
|
{
|
|
m_mutePrevVolume = currentVolume;
|
|
setVolume(0);
|
|
}
|
|
}
|
|
|
|
int8_t cKeyStoneCOMM::volume()
|
|
{
|
|
uint16_t dwBytes;
|
|
unsigned char output[] = {HEAD,0x01,0x23,0x01,0x00,0x00,END};
|
|
unsigned char input[8] = {0};
|
|
|
|
if(!writeSerialBytes(output, 7, &dwBytes))
|
|
return(-1);
|
|
|
|
if(dwBytes != 7)
|
|
return(-1);
|
|
|
|
if(!readSerialBytes(input, &dwBytes))
|
|
return(-1);
|
|
else
|
|
{
|
|
if(goodHeader(input, dwBytes))
|
|
{
|
|
m_currentVolume = input[6];
|
|
return(input[6]);
|
|
}
|
|
else
|
|
return(-1);
|
|
}
|
|
}
|
|
|
|
int8_t cKeyStoneCOMM::signalStrength()
|
|
{
|
|
int biterror;
|
|
int8_t signalStrength = getSignalStrength(&biterror);
|
|
if(signalStrength < 0)
|
|
signalStrength = 0;
|
|
return(signalStrength);
|
|
}
|
|
|
|
QString cKeyStoneCOMM::programName()
|
|
{
|
|
return(getProgramName(m_currentMode, m_currentProgram, 1));
|
|
}
|
|
|
|
QString cKeyStoneCOMM::programType()
|
|
{
|
|
int8_t programType = getProgramType(m_currentMode, m_currentProgram);
|
|
|
|
if(programType < 0 || programType > 31)
|
|
return("");
|
|
|
|
return(programTypeText[programType]);
|
|
}
|
|
|
|
QString cKeyStoneCOMM::programText()
|
|
{
|
|
return(getProgramText());
|
|
}
|
|
|
|
bool cKeyStoneCOMM::hardMute()
|
|
{
|
|
m_hardMute = true;
|
|
|
|
#ifdef Q_OS_WIN
|
|
if(!::EscapeCommFunction(m_serialPort->handle(), CLRRTS))
|
|
return(false);
|
|
if(!::EscapeCommFunction(m_serialPort->handle(), CLRDTR))
|
|
return(false);
|
|
#elif defined Q_OS_LINUX
|
|
int status;
|
|
ioctl(m_serialPort->handle, TIOCMGET, &status);
|
|
status &= ~TIOCM_RTS;
|
|
ioctl(m_serialPort->handle, TIOCMSET, &status);
|
|
#endif
|
|
|
|
QThread::msleep(350);
|
|
|
|
return(true);
|
|
}
|
|
|
|
bool cKeyStoneCOMM::hardUnmute()
|
|
{
|
|
QThread::msleep(850);
|
|
|
|
#ifdef Q_OS_WIN
|
|
if(!::EscapeCommFunction(m_serialPort->handle(), SETRTS))
|
|
return(false);
|
|
if(!::EscapeCommFunction(m_serialPort->handle(), CLRDTR))
|
|
return(false);
|
|
#elif defined Q_OS_LINUX
|
|
int status;
|
|
ioctl(m_serialPort->handle(), TIOCMGET, &status);
|
|
status |= TIOCM_RTS;
|
|
ioctl(m_serialPort->handle(), TIOCMSET, &status);
|
|
#endif
|
|
|
|
m_hardMute = false;
|
|
|
|
return(true);
|
|
}
|
|
|
|
bool cKeyStoneCOMM::hardResetRadio()
|
|
{
|
|
#ifdef Q_OS_WIN
|
|
if(EscapeCommFunction(m_serialPort->handle(), SETRTS))
|
|
{
|
|
EscapeCommFunction(m_serialPort->handle(), SETDTR);
|
|
Sleep(100);
|
|
if (EscapeCommFunction(m_serialPort->handle(), SETRTS))
|
|
{
|
|
EscapeCommFunction(m_serialPort->handle(), CLRDTR);
|
|
QThread::msleep(1000);
|
|
|
|
return(true);
|
|
}
|
|
else
|
|
return(false);
|
|
}
|
|
else
|
|
return(false);
|
|
#elif defined Q_OS_LINUX
|
|
int status;
|
|
ioctl(m_serialPort->handle(), TIOCMGET, &status);
|
|
status |= TIOCM_DTR; // set DTR pin low to reset module
|
|
ioctl(m_serialPort->handle(), TIOCMSET, &status);
|
|
usleep(100000);
|
|
status &= ~TIOCM_DTR; // set DTR pin HIGH to disable RESET
|
|
ioctl(m_serialPort->handle(), TIOCMSET, &status);
|
|
usleep(1000000); // delay 1 sec to wait for module to ready
|
|
#endif
|
|
}
|
|
|
|
bool cKeyStoneCOMM::isSysReady()
|
|
{
|
|
uint16_t dwBytes;
|
|
|
|
unsigned char input[8] = {0};
|
|
unsigned char output[] = {HEAD,0x00,0x00,0x01,0x00,0x00,END};
|
|
|
|
if(m_serialPort && m_serialPort->isOpen())
|
|
{
|
|
if(!writeSerialBytes(output, 7, &dwBytes))
|
|
return(false);
|
|
|
|
if(!readSerialBytes(input, &dwBytes))
|
|
return(false);
|
|
|
|
if(dwBytes < 7)
|
|
return(false);
|
|
|
|
if(goodHeader(input, dwBytes))
|
|
{
|
|
if(input[2] == 0x01)
|
|
return(true);
|
|
else
|
|
return(false);
|
|
}
|
|
else
|
|
return(false);
|
|
}
|
|
else
|
|
return(false);
|
|
}
|
|
|
|
bool cKeyStoneCOMM::readSerialBytes(unsigned char* buffer, uint16_t* bytesreadreturn)
|
|
{
|
|
m_readData.clear();
|
|
m_cntReadData = 0;
|
|
m_serialReadError = false;
|
|
|
|
while(m_serialPort->waitForReadyRead(100));
|
|
|
|
if(m_serialReadError)
|
|
{
|
|
*bytesreadreturn = 0;
|
|
qDebug() << "error";
|
|
return(false);
|
|
}
|
|
*bytesreadreturn = m_readData.count();
|
|
std::memcpy(buffer, m_readData.data(), *bytesreadreturn);
|
|
|
|
return(true);
|
|
}
|
|
|
|
bool cKeyStoneCOMM::writeSerialBytes(unsigned char* buffer, uint16_t nNumberOfBytesToWrite, uint16_t* lpNumberOfBytesWritten)
|
|
{
|
|
int i;
|
|
|
|
i = m_serialPort->write(reinterpret_cast<char*>(buffer), nNumberOfBytesToWrite);
|
|
if(i != nNumberOfBytesToWrite)
|
|
return(false);
|
|
|
|
*lpNumberOfBytesWritten = i;
|
|
return(true);
|
|
}
|
|
|
|
bool cKeyStoneCOMM::goodHeader(unsigned char* input, uint16_t dwBytes)
|
|
{
|
|
if((input[0] == HEAD) && (input[dwBytes-1] == END))
|
|
return(true);
|
|
else
|
|
return(false);
|
|
}
|
|
|
|
bool cKeyStoneCOMM::GPIO_SetLevel(char pin, char level)
|
|
{
|
|
uint16_t dwBytes;
|
|
unsigned char input[7] = { 0 };
|
|
unsigned char output[] = { HEAD,0x08,0x01,0x00,0x00,0x02,0x00,0x00,END };
|
|
|
|
output[6] = pin;
|
|
output[7] = level;
|
|
|
|
if (!writeSerialBytes(output, 9, &dwBytes))
|
|
return(false);
|
|
|
|
if(dwBytes != 9)
|
|
return(false);
|
|
|
|
if(!readSerialBytes(input, &dwBytes))
|
|
return(false);
|
|
|
|
if(!goodHeader(input, dwBytes))
|
|
return(false);
|
|
else
|
|
{
|
|
if((input[1] == 0x00) && (input[2] == 0x01))
|
|
return(true);
|
|
else
|
|
return(false);
|
|
}
|
|
}
|
|
|
|
bool cKeyStoneCOMM::GPIO_GetLevel(char pin, char* level)
|
|
{
|
|
uint16_t dwBytes;
|
|
unsigned char input[8] = { 0 };
|
|
unsigned char output[] = { HEAD,0x08,0x02,0x00,0x00,0x01,0x00,END };
|
|
|
|
output[6] = pin;
|
|
|
|
if(!writeSerialBytes(output, 9, &dwBytes))
|
|
return(false);
|
|
|
|
if(dwBytes != 9)
|
|
return(false);
|
|
|
|
if(!readSerialBytes(input, &dwBytes))
|
|
return(false);
|
|
|
|
if(!goodHeader(input, dwBytes))
|
|
return(false);
|
|
else
|
|
{
|
|
if((input[1] == 0x08) && (input[2] == 0x02))
|
|
{
|
|
*level = input[6];
|
|
return(true);
|
|
}
|
|
else
|
|
return(false);
|
|
}
|
|
}
|
|
|
|
bool cKeyStoneCOMM::GPIO_SetFunction(char pin, char pinfunction, char drive)
|
|
{
|
|
uint16_t dwBytes;
|
|
unsigned char input[7] = { 0 };
|
|
unsigned char output[] = { HEAD,0x08,0x00,0x00,0x00,0x03,0x00,0x00,0x00,END };
|
|
|
|
output[6] = pin;
|
|
output[7] = pinfunction;
|
|
output[8] = drive;
|
|
|
|
if(!writeSerialBytes(output, 10, &dwBytes))
|
|
return(false);
|
|
|
|
if(dwBytes != 10)
|
|
return(false);
|
|
|
|
if(!readSerialBytes(input, &dwBytes))
|
|
return(false);
|
|
|
|
if(!goodHeader(input, dwBytes))
|
|
return(false);
|
|
else
|
|
{
|
|
if((input[1] == 0x00) && (input[2] == 0x01))
|
|
{
|
|
return(true);
|
|
}
|
|
else
|
|
return(false);
|
|
}
|
|
}
|
|
|
|
int16_t cKeyStoneCOMM::getTotalProgram()
|
|
{
|
|
uint16_t dwBytes;
|
|
unsigned char output[] = {HEAD,0x01,0x13,0x01,0x00,0x00,END};
|
|
unsigned char input[11] = {0};
|
|
|
|
if(!writeSerialBytes(output, 7, &dwBytes))
|
|
return(0);
|
|
|
|
if(!readSerialBytes(input, &dwBytes))
|
|
return(0);
|
|
else
|
|
{
|
|
if(goodHeader(input, dwBytes))
|
|
{
|
|
if(input[1] == 0x01)
|
|
{
|
|
uint16_t total = (0xFF & input[6]) << 24 | (0xFF & input[7]) << 16 | (0xFF & input[8]) << 8 |(0xFF & input[9]);
|
|
m_totalProgram = total;
|
|
return(total);
|
|
}
|
|
else
|
|
return(0);
|
|
}
|
|
else
|
|
return(0);
|
|
}
|
|
}
|
|
|
|
int8_t cKeyStoneCOMM::getSignalStrength(int* biterror)
|
|
{
|
|
uint16_t dwBytes;
|
|
char dabStrength = 0;
|
|
unsigned char input[10] = {0};
|
|
unsigned char output[] = {HEAD,0x01,0x15,0x01,0x00,0x00,END};
|
|
double temp;
|
|
|
|
if(!writeSerialBytes(output, 7, &dwBytes))
|
|
return(-1);
|
|
|
|
if(dwBytes != 7)
|
|
return(-1);
|
|
|
|
if(!readSerialBytes(input, &dwBytes))
|
|
return(-1);
|
|
|
|
if(dwBytes < 8)
|
|
return(-1);
|
|
|
|
if(goodHeader(input, dwBytes))
|
|
{
|
|
if(input[5] == 0x01)
|
|
{
|
|
*biterror = 0;
|
|
return(input[6]); //FM Strength
|
|
}
|
|
|
|
if(input[5] == 0x03)
|
|
{
|
|
if(input[6] > 0)
|
|
{
|
|
// calculate percentage and return bit error
|
|
*biterror = (0xFF & input[7]) << 8 |(0xFF & input[8]);
|
|
temp = 100.00/18.00;
|
|
temp = temp * input[6];
|
|
dabStrength = (char)temp;
|
|
|
|
return(dabStrength);
|
|
}
|
|
else
|
|
return(0);
|
|
}
|
|
|
|
return(-1);
|
|
}
|
|
else
|
|
return(-1);
|
|
}
|
|
|
|
QString cKeyStoneCOMM::getProgramText()
|
|
{
|
|
uint16_t dwBytes;
|
|
unsigned char input[TEXT_BUFFER_LEN] = {0};
|
|
unsigned char output[] = {HEAD,0x01,0x2E,0x01,0x00,0x00,END};
|
|
QString programText;
|
|
|
|
if(!writeSerialBytes(output, 7, &dwBytes))
|
|
return(programText);
|
|
|
|
if(dwBytes != 7)
|
|
return(programText);
|
|
|
|
if(!readSerialBytes(input, &dwBytes))
|
|
return(programText);
|
|
|
|
if(dwBytes < 8)
|
|
return(programText);
|
|
|
|
if(goodHeader(input, dwBytes))
|
|
{
|
|
if((input[1] == 0x01) && (input[2] == 0x2E))
|
|
{
|
|
int textLen = (0xFF & input[4]) << 8 |(0xFF & input[5]);
|
|
|
|
if(textLen > TEXT_BUFFER_LEN-1)
|
|
return(programText); // buffer overrun
|
|
|
|
int unicodesize = textLen/2;
|
|
char front;
|
|
|
|
for(int i = 0;i < textLen;i += 2) // WATCHOUT
|
|
{
|
|
front = input[6+i];
|
|
input[6+i] = input[6+i+1];
|
|
input[6+i+1] = front;
|
|
}
|
|
#ifdef WIN32
|
|
programText = QString::fromWCharArray((wchar_t *)&input[6], unicodesize-1).trimmed();
|
|
|
|
#ifdef LABVIEW
|
|
int asciilen=WideCharToMultiByte(CP_ACP, 0, programText, unicodesize-1, NULL,0,NULL,NULL);
|
|
char *asciitext = new char[asciilen+1];
|
|
WideCharToMultiByte(CP_ACP, 0, programText, unicodesize-1, asciitext, asciilen, NULL, NULL);
|
|
asciitext[asciilen]=0;
|
|
memset((char*)programText,0, asciilen+1);
|
|
memcpy((char*)programText, asciitext, asciilen);
|
|
delete asciitext;
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#ifdef __linux__
|
|
unsigned char tempBuffer[TEXT_BUFFER_LEN*4]={0};
|
|
|
|
for(int i=0; i< unicodesize;i++)
|
|
{
|
|
tempBuffer[i*4]=input[6+(i*2)];
|
|
tempBuffer[(i*4)+1]=input[6+(i*2)+1];
|
|
tempBuffer[(i*4)+2]=0;
|
|
tempBuffer[(i*4)+3]=0;
|
|
}
|
|
|
|
programText = QString::fromWCharArray((wchar_t *)&tempBuffer[0], unicodesize-1).trimmed();
|
|
#endif
|
|
return(programText);
|
|
|
|
}
|
|
else if((input[1] == 0x00) && (input[2] == 0x02))
|
|
{
|
|
if(input[6] == 0x01)
|
|
return(programText);
|
|
else
|
|
return(programText);
|
|
}
|
|
else
|
|
return(programText);
|
|
}
|
|
else
|
|
return(programText);
|
|
}
|
|
|
|
int8_t cKeyStoneCOMM::getProgramType(char mode, long dabIndex)
|
|
{
|
|
uint16_t dwBytes;
|
|
unsigned char input[9] = {0};
|
|
unsigned char output[] = {HEAD,0x01,0x2C,0x01,0x00,0x04,0xFF,0xFF,0xFF,0xFF,END};
|
|
unsigned char strChannel[4] = {0};
|
|
|
|
if((mode != STREAM_MODE_DAB) && (mode != STREAM_MODE_FM))
|
|
return(-1);
|
|
|
|
if(mode == STREAM_MODE_DAB)
|
|
{
|
|
memcpy(&strChannel[0], &dabIndex, sizeof(long));
|
|
output[6] = strChannel[3];
|
|
output[7] = strChannel[2];
|
|
output[8] = strChannel[1];
|
|
output[9] = strChannel[0];
|
|
}
|
|
|
|
if(!writeSerialBytes(output, 11, &dwBytes))
|
|
return(-1);
|
|
|
|
if(dwBytes != 11)
|
|
return(-1);
|
|
|
|
if(!readSerialBytes(input, &dwBytes))
|
|
return(-1);
|
|
|
|
if(dwBytes != 8)
|
|
return(-1);
|
|
|
|
if(goodHeader(input, dwBytes))
|
|
{
|
|
if((input[1] == 0x01) && (input[2] == 0x2C))
|
|
return(input[6]);
|
|
else
|
|
return(-1);
|
|
}
|
|
else
|
|
return(-1);
|
|
}
|
|
|
|
QString cKeyStoneCOMM::getProgramName(char mode, long dabIndex, char namemode)
|
|
{
|
|
uint16_t dwBytes;
|
|
unsigned char input[50] = {0};
|
|
unsigned char output[] = {HEAD,0x01,0x2D,0x01,0x00,0x05,0xFF,0xFF,0xFF,0xFF,0x01,END};
|
|
unsigned char strChannel[4] = {0};
|
|
QString programName;
|
|
|
|
if((mode != STREAM_MODE_DAB) && (mode != STREAM_MODE_FM))
|
|
return(programName);
|
|
|
|
if(mode == STREAM_MODE_DAB)
|
|
{
|
|
memcpy(&strChannel[0], &dabIndex, sizeof(long));
|
|
output[6] = strChannel[3];
|
|
output[7] = strChannel[2];
|
|
output[8] = strChannel[1];
|
|
output[9] = strChannel[0];
|
|
}
|
|
|
|
output[10] = namemode;
|
|
|
|
if(!writeSerialBytes(output, 12, &dwBytes))
|
|
return(programName);
|
|
|
|
if(dwBytes != 12)
|
|
return(programName);
|
|
|
|
if(!readSerialBytes(input, &dwBytes))
|
|
return(programName);
|
|
|
|
if(dwBytes < 8)
|
|
return(programName);
|
|
|
|
if(goodHeader(input, dwBytes))
|
|
{
|
|
if((input[1] == 0x01) && (input[2] == 0x2D))
|
|
{
|
|
int textLen = (int)input[5];
|
|
|
|
if(textLen > 50)
|
|
return(programName); // prevent buffer overrun
|
|
|
|
int unicodesize = textLen/2;
|
|
char front;
|
|
|
|
for(int i = 0;i < textLen;i += 2)
|
|
{
|
|
front = input[6+i];
|
|
input[6+i] = input[6+i+1];
|
|
input[6+i+1] = front;
|
|
}
|
|
|
|
#ifdef WIN32
|
|
programName = QString::fromWCharArray((wchar_t*)&input[6], unicodesize-1).trimmed();
|
|
|
|
#ifdef LABVIEW
|
|
int asciilen=WideCharToMultiByte(CP_ACP, 0, programName, unicodesize-1, NULL,0,NULL,NULL);
|
|
char *asciitext = new char[asciilen+1];
|
|
WideCharToMultiByte(CP_ACP, 0, programName, unicodesize-1, asciitext, asciilen, NULL, NULL);
|
|
asciitext[asciilen]=0;
|
|
memset((char*)programName,0, asciilen+1);
|
|
memcpy((char*)programName, asciitext, asciilen);
|
|
delete asciitext;
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#ifdef __linux__
|
|
unsigned char tempBuffer[TEXT_BUFFER_LEN*4]={0};
|
|
|
|
for(int i=0; i< unicodesize;i++)
|
|
{
|
|
tempBuffer[i*4]=input[6+(i*2)];
|
|
tempBuffer[(i*4)+1]=input[6+(i*2)+1];
|
|
tempBuffer[(i*4)+2]=0;
|
|
tempBuffer[(i*4)+3]=0;
|
|
}
|
|
|
|
programName = QString::fromWCharArray((wchar_t *)&tempBuffer[0], unicodesize-1).trimmed();
|
|
#endif
|
|
return(programName);
|
|
|
|
}
|
|
else
|
|
return(programName);
|
|
}
|
|
else
|
|
return(programName);
|
|
}
|
|
|
|
void cKeyStoneCOMM::serialReadReady()
|
|
{
|
|
m_readData.append(m_serialPort->readAll());
|
|
}
|
|
|
|
//void cKeyStoneCOMM::handleTimeout()
|
|
//{
|
|
//}
|
|
|
|
void cKeyStoneCOMM::serialReadError(QSerialPort::SerialPortError error)
|
|
{
|
|
if(error == QSerialPort::ReadError)
|
|
{
|
|
m_serialReadError = true;
|
|
m_serialPortError = error;
|
|
#ifdef OUTPUT_DEBUG
|
|
qDebug() << error;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
|
|
bool cKeyStoneCOMM::clearDatabase()
|
|
{
|
|
uint16_t dwBytes;
|
|
unsigned char input[8] = {0};
|
|
unsigned char output[] = {HEAD,0x00,0x01,0x01,0x00,0x01,0x01,END};
|
|
|
|
if(!writeSerialBytes(output, 8, &dwBytes))
|
|
return(false);
|
|
|
|
// need to check the return
|
|
if(!readSerialBytes(input, &dwBytes))
|
|
return(false);
|
|
else
|
|
{
|
|
if(goodHeader(input, dwBytes))
|
|
{
|
|
if(input[2] == 0x01)
|
|
{
|
|
QThread::msleep(1000);
|
|
|
|
// while(!isSysReady())
|
|
// {
|
|
// QThread::msleep(1000);
|
|
// }
|
|
|
|
return(true);
|
|
}
|
|
else
|
|
return(false);
|
|
}
|
|
else
|
|
return(false);
|
|
}
|
|
|
|
return(true);
|
|
}
|
|
|
|
bool cKeyStoneCOMM::clearFM()
|
|
{
|
|
return(true);
|
|
}
|
|
|
|
bool cKeyStoneCOMM::clearDAB()
|
|
{
|
|
clearDatabase();
|
|
|
|
return(true);
|
|
}
|