xavi
/
qpsxserial
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
qpsxserial/qpsxserial.cpp

807 lines
19 KiB
C++
Raw Permalink Blame History

#include <QFileDialog>
#include <QFile>
#include <QSerialPortInfo>
#include "qpsxserial.h"
#include "ui_qpsxserial.h"
#define LOST_PACKET_TIMEOUT 3000
#define CONNECT_TO_PSX_TIMEOUT 500
QPSXSerial::QPSXSerial(QWidget *parent, APP_INTERFACE interface) :
QMainWindow(parent),
ui(new Ui::QPSXSerial),
stdout_ui(new Ui::Stdout_Console),
stdout_dialog(new QDialog),
app_interface(interface),
ack(false),
exe_sent(false),
write_ready(false),
byte_sent_received(false),
first_entered(false),
disable_psx_stdout(false)
{
connect(&lost_packet_timer, SIGNAL(timeout()), this, SLOT(onPacketLost()));
connect(&serial, SIGNAL(bytesWritten(qint64)), this, SLOT(onBytesWritten(qint64)));
connect(&serial, SIGNAL(readyRead()), this, SLOT(onReadyRead(void)));
init_timer.setSingleShot(true);
init_timer.setInterval(CONNECT_TO_PSX_TIMEOUT);
connect(&init_timer, SIGNAL(timeout(void)), this, SLOT(connectToPSXTimeout(void)));
if (app_interface == GUI_APP)
{
ui->setupUi(this);
connect(ui->stdout_Button, SIGNAL(released()), this, SLOT(onStdOutButtonReleased()));
connect(ui->loadFile_Btn, SIGNAL(released()), this, SLOT(onLoadFileBtnReleased()));
connect(ui->updatePorts_Btn, SIGNAL(released()), this, SLOT(onUpdatePortsBtnReleased()));
connect(ui->send_Btn, SIGNAL(released()), this, SLOT(onSendBtnReleased()));
connect(ui->ports_ComboBox, SIGNAL(currentIndexChanged(QString)), this, SLOT(onPortSelectedComboBox(QString)));
ui->exeProgressBar->setVisible(false);
ui->send_Btn->setEnabled(false);
ui->inFileName->setVisible(false);
stdout_ui->setupUi(stdout_dialog);
connect(stdout_ui->clean_Btn, SIGNAL(released()), stdout_ui->stdout_Log, SLOT(clear()));
connect(stdout_ui->close_Btn, SIGNAL(released()), stdout_dialog, SLOT(close()));
connect(this, SIGNAL(debug_frame_received(QString)), stdout_ui->stdout_Log, SLOT(append(QString)));
setWindowTitle( "QPSXSerial "
+ QString(QPSXSERIAL_VERSION_STR) );
}
}
QPSXSerial::~QPSXSerial()
{
delete ui;
}
void QPSXSerial::onStdOutButtonReleased(void)
{
stdout_dialog->show();
}
void QPSXSerial::showError(QString error)
{
QMessageBox box(QMessageBox::Critical, "QPSXSerial serror", error);
box.show();
}
void QPSXSerial::onLoadFileBtnReleased(void)
{
selectedFolder = QFileDialog::getExistingDirectory( this,
"Load folder with PSX data",
"C:/",
QFileDialog::ShowDirsOnly );
if (selectedFolder.isEmpty())
{
return;
}
ui->loadedFile_LineEdit->setText(selectedFolder);
inputExe = getInputExeFromFolder(&selectedFolder);
if (selectedPort.isEmpty() == false)
{
ui->send_Btn->setEnabled(true);
}
}
void QPSXSerial::onUpdatePortsBtnReleased(void)
{
ui->ports_ComboBox->clear();
foreach(QSerialPortInfo port, QSerialPortInfo::availablePorts())
{
ui->ports_ComboBox->addItem(port.portName());
}
}
void QPSXSerial::onSendBtnReleased(void)
{
if (serial.isOpen() == false)
{
if (selectedPort.isEmpty())
{
showGUICLIerror("No selected port!");
return;
}
serial.setPortName(selectedPort);
serial.setBaudRate(QSerialPort::Baud115200);
serial.setParity(QSerialPort::NoParity);
serial.setDataBits(QSerialPort::Data8);
serial.setStopBits(QSerialPort::OneStop);
if (serial.open(QIODevice::ReadWrite) == false)
{
showGUICLIerror("Could not open port " + selectedPort);
return;
}
init_timer.start();
if (app_interface == GUI_APP)
{
ui->exeProgressBar->setVisible(true);
ui->exeProgressBar->setMinimum(0);
ui->exeProgressBar->setMaximum(0);
ui->inFileName->setText("Waiting for response from the device...");
ui->inFileName->setVisible(true);
ui->send_Btn->setText("Disconnect from PSX");
}
else
{
printf("Connected to port successfully.\n");
printf("Waiting for response from the device...\n");
}
}
else
{
if (app_interface == GUI_APP)
{
ui->send_Btn->setText("Send to PSX!");
ui->exeProgressBar->setVisible(false);
ui->inFileName->clear();
}
serial.close();
first_entered = false;
exe_sent = false;
lost_packet_timer.stop();
init_timer.stop();
}
}
void QPSXSerial::connectToPSXTimeout(void)
{
QByteArray ba;
if (ack == false)
{
ba.append(99);
serial.write(ba);
init_timer.start(CONNECT_TO_PSX_TIMEOUT);
}
}
void QPSXSerial::onPortSelectedComboBox(QString port)
{
selectedPort = port;
if (inputExe.isEmpty() == false)
{
ui->send_Btn->setEnabled(true);
}
}
void QPSXSerial::onBytesWritten(qint64)
{
write_ready = true;
}
void QPSXSerial::onReadyRead(void)
{
const QByteArray data = serial.readAll();
static QTime time = QTime::currentTime();
static bool cdrom_petition;
if (exe_sent)
{
static QByteArray fileName;
if (data.contains("#"))
{
cdrom_petition = true;
fileName.clear();
}
if (data.count() == 1)
{
if (data.at(0) == 'b')
{
ack = true;
return;
}
}
qDebug() << data;
if (cdrom_petition)
{
if (data.contains("#"))
{
int initial_i = data.indexOf("#");
qDebug() << initial_i;
fileName.append(data.mid(initial_i, data.count() - initial_i));
}
else
{
fileName.append(data);
}
if (fileName.contains("@"))
{
int terminator_i = fileName.indexOf("@");
if (terminator_i >= fileName.count())
{
fileName.chop(terminator_i - fileName.count() - 1);
}
cdrom_petition = false;
qDebug() << "INPUT FRAME: " + fileName;
QString filePath = QString(fileName);
filePath.remove("@");
filePath.remove("#");
filePath.remove("cdrom:\\");
qDebug() << "selectedFolder = " + selectedFolder;
filePath.prepend(selectedFolder);
filePath.replace("\\", "/");
filePath.chop(2); // Remove ending ";1"
qDebug() << "filePath = " + filePath;
QFile f(filePath);
if (f.open(QFile::ReadOnly) == false)
{
qDebug() << "Error while reading input file!";
return;
}
QByteArray file_data = f.readAll();
quint32 sz = file_data.count();
sendDataSize(sz);
if (serial.waitForReadyRead() == false)
{
qDebug() << "Did not receive any ACK!";
}
else
{
qDebug() << "sendData for file...";
onReadyRead();
sendData(file_data, filePath);
f.close();
}
}
}
else
{
if (app_interface == GUI_APP)
{
emit debug_frame_received(QString(data));
}
else if (app_interface == CLI_APP)
{
if (disable_psx_stdout == false)
{
const char* string_received = data.toStdString().c_str();
printf("%s\n", string_received);
}
}
}
}
if (data.isEmpty() == false)
{
quint8 data_byte = static_cast<quint8>(data.at(0));
if (data_byte == 'b')
{
// Received handshaking byte. Start transmission!
ack = true;
init_timer.stop();
if (first_entered == false)
{
first_entered = true;
if (sendExe() == false)
{
qDebug() << "An error happened when sending EXE file!";
}
exe_sent = true;
}
}
}
time = QTime::currentTime();
}
bool QPSXSerial::sendExe(void)
{
QFile f(inputExe);
if (f.open(QFile::ReadOnly) == false)
{
qDebug() << "Could not open input EXE file!";
return false;
}
f.seek(0);
ack = false;
QByteArray data = f.read(2048 /* PSX-EXE header */);
if (app_interface == GUI_APP)
{
ui->inFileName->setText("Sending PSX-EXE size...");
}
else if (app_interface == CLI_APP)
{
printf("Sending PSX-EXE header data...\n");
}
// PSX-EXE header is actually 2048 bytes long, but initial 32 bytes
// contain all the information we need for this.
for (int i = 0; i < 32; i+=4)
{
QByteArray send;
write_ready = false;
QThread::msleep(100);
QApplication::processEvents();
qDebug() << "Sending " + data.mid(i, 4).toHex();
send.append(data.mid(i, 4));
serial.write(send);
}
if (app_interface == GUI_APP)
{
ui->inFileName->setText("Sending PSX-EXE size...");
}
else if (app_interface == CLI_APP)
{
printf("Sending PSX-EXE size...\n");
}
if (serial.waitForReadyRead() == false)
{
qDebug() << "Did not receive any ACK!";
}
else
{
onReadyRead();
}
qDebug () << "Sending EXE size...";
qint64 sz = f.size() - 2048;
sendDataSize(static_cast<quint32>(sz));
if (serial.waitForReadyRead() == false)
{
qDebug() << "Did not receive any ACK!";
}
else
{
onReadyRead();
}
// Send file size without header
qDebug() << "Dump EXE data...";
f.seek(2048);
data = f.readAll();
qDebug() << data.count();
sendData(data, inputExe);
f.close();
qDebug() << "PSX-EXE sent successfully!";
return true;
}
void QPSXSerial::sendDataSize(quint32 size)
{
QByteArray ar;
for (unsigned int i = 0; i < sizeof(quint32); i++)
{
char send = (char)( size >> (i << 3) );
QByteArray send_arr;
send_arr.append(send);
ar.append(send);
serial.write(send_arr);
while (write_ready == false)
{
QApplication::processEvents();
}
}
/*for (unsigned int i = 0; i < sizeof(quint32); i++)
{
qDebug() << "0x" + QString::number(ar.at(i), 16);
}*/
ack = false;
}
void QPSXSerial::onPacketLost(void)
{
qDebug() << "Entering onPacketLost...";
if (ack == false)
{
serial.write(last_packet_sent);
lost_packet_timer.start(LOST_PACKET_TIMEOUT);
}
}
void QPSXSerial::sendData(QByteArray data, QString fileName)
{
static int last_i;
last_i = 0;
if (app_interface == GUI_APP)
{
ui->exeProgressBar->setVisible(true);
ui->exeProgressBar->setRange(0, data.count());
ui->inFileName->setText(fileName);
ui->inFileName->setVisible(true);
}
lost_packet_timer.setInterval(LOST_PACKET_TIMEOUT);
lost_packet_timer.setSingleShot(true);
for (int i = 0; i < data.count(); i+= 8)
{
QByteArray send;
ack = false;
send.append(data.mid(i, 8));
//qDebug() << "Sent packet";
QApplication::processEvents();
serial.write(send);
last_packet_sent = send;
lost_packet_timer.start(LOST_PACKET_TIMEOUT);
if (serial.waitForReadyRead() == false)
{
qDebug() << "Did not receive any ACK!";
}
else
{
onReadyRead();
}
if (app_interface == GUI_APP)
{
ui->exeProgressBar->setValue(i);
}
else if (app_interface == CLI_APP)
{
if ( ( (i - last_i) > (data.count() >> 7))
||
(i > (data.count() - (data.count() >> 7) ) ) )
{
int j;
bool draw_arrow = true;
// Fancy, CLI progress bar
printf("\r");
printf("|");
for (j = 0; j < data.count(); j += data.count() >> 5)
{
if (i > j)
{
printf("=");
}
else if (i < j)
{
if (draw_arrow)
{
draw_arrow = false;
printf(">");
}
printf(" ");
}
else
{
printf(">");
}
}
printf("|");
printf("\t%d/%d bytes sent...", i, data.count());
last_i = i;
}
}
}
printf("\n");
lost_packet_timer.stop();
if (app_interface == GUI_APP)
{
ui->exeProgressBar->setValue(data.count());
ui->inFileName->setText("Transfer complete!");
}
else if (app_interface == CLI_APP)
{
printf("Transfer complete!\n");
}
ack = false;
}
void QPSXSerial::cli_run(void)
{
QStringList allowed_flags;
bool correct_flag_used = false;
allowed_flags.append("--help");
allowed_flags.append("--port");
allowed_flags.append("--inpath");
foreach(QString flag, allowed_flags)
{
if (_paramlist.contains(flag))
{
correct_flag_used = true;
break;
}
}
if ( (_paramlist.count() < 2) ||
(_paramlist.contains("--help")) ||
(correct_flag_used == false) )
{
showHelp();
emit finished();
return;
}
// Check specified port
int port_i = _paramlist.indexOf("--port");
if (port_i == -1)
{
printf("No port specified! Please include \"--port\" flag and port name e.g.: \"--port COM7\"\n");
emit finished();
return;
}
if (_paramlist.count() > (++port_i ) )
{
selectedPort = _paramlist.at(port_i);
}
else
{
printf("No port name specified! Please write port name e.g.: \"--port COM7\"\n");
emit finished();
return;
}
// Check specified folder
int folder_i = _paramlist.indexOf("--input_folder");
if (folder_i == -1)
{
printf("No input folder has been specified. Please include \"--help\" for further reference"
" about QPSXSerial usage.\n");
emit finished();
return;
}
if (_paramlist.count() > (++folder_i ) )
{
selectedFolder = _paramlist.at(folder_i);
}
else
{
printf( "No input folder path! Please write valid folder path e.g.: "
"--input-folder ~/MyGame/cdimg\n");
emit finished();
return;
}
inputExe = getInputExeFromFolder(&selectedFolder);
if (inputExe.isEmpty())
{
printf("Could not find PSX-EXE from specified input folder.\n");
emit finished();
return;
}
// Check optional flags
int psx_sdtout_flag = _paramlist.indexOf("--disable_psx_stdout");
if (psx_sdtout_flag != -1)
{
disable_psx_stdout = true;
}
else
{
disable_psx_stdout = false;
}
onSendBtnReleased();
}
void QPSXSerial::showHelp(void)
{
printf("##########################\n");
printf("QPSXSerial version %s\n", QPSXSERIAL_VERSION_STR);
printf("##########################\n");
printf("This application allows uploading PSX-EXE files to a PlayStation 1\n");
printf("console (also known as PSX) using serial port interface.\n");
printf("To be used together with OpenSend, available on the link below:\n");
printf("\n%s\n\n", OPENSEND_URL);
printf("Report any bugs, issues or suggestions on the official Github repository for QPSXSerial:\n");
printf("\n%s\n\n", QPSXSERIAL_URL);
printf("Usage:\n\n");
printf("QPSXSerial --input_folder inpath --port PORTNAME [options]\n\n");
printf("The following options are available:\n");
printf("--disable_psx_stdout\t\tDisables stdout messages from console to PC\n\n");
printf("Additionally to PSX-EXEs, QPSXSerial can also send external files e.g.:\n"
"*.TIM or *.VAG files whenever the game requests such data.\n");
printf("A working example of this bidirectional communication can be found on my open-source\n");
printf("video game \"Airport\", available on the following Github repository:\n");
printf("\nhttps://github.com/XaviDCR92/Airport/\n\n");
printf("QPSXSerial, OpenSend and Airport written by Xavier Del Campo (aka Xavi92).\n");
printf("All software released under the General Public License (GPL-3.0).\n");
printf("This application has been created using Qt toolkit %s\n", QT_VERSION_STR);
printf("\nINFO: In case you do not set any parameters, GUI is enabled by default.\n");
}
QString QPSXSerial::getInputExeFromFolder(QString* folder)
{
QFile system_f(*folder + "\\SYSTEM.CNF");
QString fileSelected;
QString retExe;
if ( (folder->endsWith("/") == false) && (folder->endsWith("\\") == false) )
{
folder->append("/");
}
if (system_f.exists() == false)
{
QDir d(*folder);
QStringList filters;
filters.append("*.EXE");
filters.append("*.exe");
QStringList exe_list = d.entryList(filters);
if (exe_list.isEmpty())
{
retExe.clear();
return retExe;
}
if (exe_list.contains("PSX.EXE"))
{
fileSelected = "PSX.EXE";
}
else
{
fileSelected = exe_list.first();
}
}
else
{
if (system_f.open(QFile::ReadOnly) == false)
{
QString error = "Could not open " + *folder + "\\SYSTEM.CNF";
showGUICLIerror(error);
retExe.clear();
return retExe;
}
QTextStream system_txt(&system_f);
do
{
QString line = system_txt.readLine();
QStringList tokens = line.split("=");
if (tokens.isEmpty())
{
continue;
}
if (tokens.at(0).contains("BOOT") == false)
{
continue;
}
fileSelected = tokens.at(1).split("\\").at(1);
fileSelected.chop(2); // Remove ";1" suffix.
break;
}while (system_txt.atEnd() == false);
}
retExe = *folder + fileSelected;
return retExe;
}
void QPSXSerial::showGUICLIerror(QString error)
{
if (app_interface == GUI_APP)
{
showError(error);
}
else if (app_interface == CLI_APP)
{
const char* c_str_error = error.toStdString().c_str();
printf("%s\n", c_str_error);
}
}
Reference in New Issue View Git Blame Copy Permalink