gfativaflashutil/qmlplugin/libgfativaflashplugin/gfativaflash.cpp

#include <stdio.h>
#include <stdarg.h>
#include <string>
#include <regex>
#include "gfativaflash.h"

#define _TEST_VERBOSITY(v, n)					(((v) == -1) && ((n) <= 2)) || (((v) >= 0) && ((v) >= (n)))

/////////////////////////////////////////////////////////////////////////////
#if 0
static std::string _formatString(const char *fmt, ...)
{
	int n;
	std::string s;
	char *p = NULL;
	va_list ap;
	va_start(ap, fmt);
	n = ::vasprintf(&p, fmt, ap);
	va_end(ap);
	if(n >= 0)
	{
		s = p;
		free(p);
	}
	return s;
}
#endif

/////////////////////////////////////////////////////////////////////////////

TivaFlash::TivaFlash(QObject *pParent) :	QObject(pParent),
											m_nExitCode(0),
											m_slvIdIsNodeAddr(false),
											m_verbosity(-1),
											m_bExecuting(false),
											m_xBaudRate(0),
											m_curSlvID(0),
											m_appAddress(0),
											m_blockSize(0),
											m_pageEraseTime(0),
											m_mbCtrlRegister(0),
											m_forceAllParities(false),
											m_imgSizeFile(0),
											m_imgCRC32File(0.0),
											m_imgUpldProg(this),
											m_qProcess(this)
{
	setObjectName("TivaFlash");

	for(int i = 0; i < _MAX_SLAVE_COUNT; i++)
	{
		m_materialEeprom.append("");
		m_serialEeprom.append("");

		m_imgSizeBoot.append(0);
		m_imgCRC32Boot.append(0.0);
		m_imgMaterialBoot.append("");
		m_imgBuildBoot.append("");

		m_imgSizeApp.append(0);
		m_imgCRC32App.append(0.0);
		m_imgMaterialApp.append("");
		m_imgBuildApp.append("");
	}

	connect(&m_qProcess, SIGNAL(started()), SLOT(onProcessStarted()));
	connect(&m_qProcess, SIGNAL(finished(int, QProcess::ExitStatus)), SLOT(onProcessFinished(int, QProcess::ExitStatus)));
	connect(&m_qProcess, SIGNAL(readyReadStandardOutput()), SLOT(onProcessReadyReadStandardOutput()));
	connect(&m_qProcess, SIGNAL(stateChanged(QProcess::ProcessState)), SLOT(onProcessStateChanged(QProcess::ProcessState)));

	m_qProcess.setProcessChannelMode(QProcess::MergedChannels);
}

TivaFlash::~TivaFlash(void)
{
}

/////////////////////////////////////////////////////////////////////////////

void TivaFlash::onProcessStarted(void)
{
	setExecuting(true);
	emit processStarted(m_curSlvID);
}

void TivaFlash::onProcessFinished(int exitCode, QProcess::ExitStatus exitStatus)
{
	setExecuting(false);
	emit processFinished(m_curSlvID, exitCode, exitStatus == QProcess::ExitStatus::NormalExit);
}

void TivaFlash::onProcessReadyReadStandardOutput(void)
{
	char szLine[256];

	while(m_qProcess.readLine(szLine, sizeof(szLine)) > 0)
	{
		onCmdOutput(m_curSlvID, szLine);
	}
}

void TivaFlash::onProcessStateChanged(QProcess::ProcessState newState)
{
	setExecuting(newState != QProcess::ProcessState::NotRunning);
}

/////////////////////////////////////////////////////////////////////////////
#if 0
bool TivaFlash::execFlashUtil(int nSlvID, const char *pszOpt)
{
	FILE* pd;
	char buffer[256];
	m_nExitCode = -1;
	std::string strCmd = _formatString("\"%s\" %s --plugin-mode 2>&1", m_tivaFlashUtilPath.c_str(), pszOpt);

	if((pd = popen(strCmd.c_str(), "r")))
	{
		while(fgets(buffer, sizeof buffer, pd))
		{
			onCmdOutput(nSlvID, buffer);
		}

		pclose(pd);
	}

	return m_nExitCode == 0;
}

/////////////////////////////////////////////////////////////////////////////

std::string TivaFlash::getSlavIDs(int nSlvID, int nMbID) const
{
	std::string ret;

	if(m_slvIdIsNodeAddr)
		ret = _formatString("--node-addr=%d", nSlvID);
	else
		ret = _formatString("--stat-num=%d", nSlvID);

	if(_IS_VALID_MB_ID(nMbID))
		ret += _formatString(" --mb-slave-id=%d", nMbID);

	return ret;
}
#endif

void TivaFlash::getSlavIDs(int nSlvID, int nMbID, QStringList &rargs) const
{
	std::string ret;

	if(m_slvIdIsNodeAddr)
		rargs << QString::asprintf("--node-addr=%d", nSlvID);
	else
		rargs << QString::asprintf("--stat-num=%d", nSlvID);

	if(_IS_VALID_MB_ID(nMbID))
	{
		rargs << QString::asprintf("--mb-slave-id=%d", nMbID);

		if(m_mbCtrlRegister > 0)
			rargs << QString::asprintf("--mb-bl-ctrl-reg=%d", m_mbCtrlRegister);
	}
}

/////////////////////////////////////////////////////////////////////////////

void TivaFlash::getXBaud(QStringList &rargs) const
{
	if(m_xBaudRate > 0)
	{
		rargs << QString::asprintf("--x-baud-rate=%d", m_xBaudRate);
	}
}

/////////////////////////////////////////////////////////////////////////////

void TivaFlash::getAppAddr(QStringList &rargs) const
{
	if(m_appAddress > 0)
	{
		rargs << QString::asprintf("--app-addr=0x%X", m_appAddress);
	}
}

/////////////////////////////////////////////////////////////////////////////

void TivaFlash::getBlockSize(QStringList &rargs) const
{
	if(m_blockSize > 0)
	{
		rargs << QString::asprintf("--block-size=%d", m_blockSize);
	}
}

/////////////////////////////////////////////////////////////////////////////

void TivaFlash::getPageEraseTime(QStringList &rargs) const
{
	if(m_pageEraseTime > 0)
	{
		rargs << QString::asprintf("--page-erase-time=%d", m_pageEraseTime);
	}
}

/////////////////////////////////////////////////////////////////////////////

void TivaFlash::getForceAllParities(QStringList &rargs) const
{
	if(m_forceAllParities)
	{
		rargs << QString::asprintf("--force-all-par");
	}
}

/////////////////////////////////////////////////////////////////////////////

int TivaFlash::parseTaggedString(const char *pszIn, std::string &sOut) const
{
	static const std::string strRegEx = "<([0-9]+)>(.+)<\\/\\1>";
	static std::regex reg(strRegEx, std::regex_constants::ECMAScript | std::regex_constants::optimize);
	std::cmatch res;

	if(pszIn && *pszIn)
	{
		try
		{
			if(regex_search(pszIn, res, reg))
			{
				size_t nSize = res.size();

				if(nSize == 3)
				{
					std::string strTagName = res[1].str();
					sOut = res[2].str();
					return atoi(strTagName.c_str());
				}
			}
		}
		catch(...)
		{
		}
	}

	return -1;
}

/////////////////////////////////////////////////////////////////////////////

int TivaFlash::parseTaggedValues(const char *pszIn, int &rnVal1, int &rnVal2) const
{
	static const std::string strRegEx = "([0-9]+)\\|([0-9]+)";
	static std::regex reg(strRegEx, std::regex_constants::ECMAScript | std::regex_constants::optimize);
	std::cmatch res;

	if(pszIn && *pszIn)
	{
		try
		{
			if(regex_search(pszIn, res, reg))
			{
				size_t nSize = res.size();

				if(nSize == 3)
				{
					rnVal1 = atoi(res[1].str().c_str());
					rnVal2 = atoi(res[2].str().c_str());
					return nSize - 1;
				}
			}
		}
		catch(...)
		{
		}
	}

	return -1;
}

/////////////////////////////////////////////////////////////////////////////

void TivaFlash::onCmdOutput(int nSlvID, const char *pszOut)
{
	std::string s;
	int nTag = parseTaggedString(pszOut, s);
	int nVal1, nVal2;

	if(nTag >= 0)
	{
		QString qs = QString::fromStdString(s);

		switch(nTag)
		{
		/////////////////////////////////////////////////////////////////////

		case PLUGIN_TAG_EXIT_CODE:
			m_nExitCode = qs.toInt();
			break;

		/////////////////////////////////////////////////////////////////////

		case PLUGIN_TAG_STATUS:
			if(_TEST_VERBOSITY(m_verbosity, PLUGIN_TAG_STATUS))
				emit processOutput(nSlvID, nTag, qs);
			break;
		case PLUGIN_TAG_INFO:
			if(_TEST_VERBOSITY(m_verbosity, PLUGIN_TAG_INFO))
				emit processOutput(nSlvID, nTag, qs);
			break;
		case PLUGIN_TAG_ERROR:
			if(_TEST_VERBOSITY(m_verbosity, PLUGIN_TAG_ERROR))
				emit processOutput(nSlvID, nTag, qs);
			break;

		/////////////////////////////////////////////////////////////////////

		case PLUGIN_TAG_IMG_MATERIAL_EEPROM:
			setMaterialEeprom(nSlvID, qs);
			break;
		case PLUGIN_TAG_IMG_SERIAL_EEPROM:
			setSerialEeprom(nSlvID, qs);
			break;

		/////////////////////////////////////////////////////////////////////

		case PLUGIN_TAG_IMG_LENGTH_BOOT:
			setImgSizeBoot(nSlvID, qs.toUInt());
			break;
		case PLUGIN_TAG_IMG_CRC32_BOOT:
			setImgCRC32Boot(nSlvID, qs.toDouble());
			break;
		case PLUGIN_TAG_IMG_BUILD_BOOT:
			setImgBuildBoot(nSlvID, qs);
			break;
		case PLUGIN_TAG_IMG_MATERIAL_BOOT:
			setImgMaterialBoot(nSlvID, qs);
			break;

		/////////////////////////////////////////////////////////////////////

		case PLUGIN_TAG_IMG_LENGTH_APP:
			setImgSizeApp(nSlvID, qs.toUInt());
			break;
		case PLUGIN_TAG_IMG_CRC32_APP:
			setImgCRC32App(nSlvID, qs.toDouble());
			break;
		case PLUGIN_TAG_IMG_MATERIAL_APP:
			setImgBuildApp(nSlvID, qs);
			break;
		case PLUGIN_TAG_IMG_BUILD_APP:
			setImgMaterialApp(nSlvID, qs);
			break;

		/////////////////////////////////////////////////////////////////////

		case PLUGIN_TAG_IMG_LENGTH_FILE:
			setImgSizeFile(qs.toUInt());
			break;
		case PLUGIN_TAG_IMG_CRC32_FILE:
			setImgCRC32File(qs.toDouble());
			break;
		case PLUGIN_TAG_IMG_MATERIAL_FILE:
			setImgMaterialFile(qs);
			break;
		case PLUGIN_TAG_IMG_BUILD_FILE:
			setImgBuildFile(qs);
			break;

		/////////////////////////////////////////////////////////////////////

		case PLUGIN_TAG_UPLOAD_START_ERASE_FLASH:
			m_imgUpldProg.clear();
			m_imgUpldProg.setCtx(ImgUploadStatus::EraseFlashStart);
			if(parseTaggedValues(s.c_str(), nVal1, nVal2) == 2)
			{
				m_imgUpldProg.setUploadInProgress(true);
				m_imgUpldProg.setCntFlashPages(nVal1);
				m_imgUpldProg.setCbTotal(nVal2);
				emit imgUploadProgress(&m_imgUpldProg);
			}
			break;
		case PLUGIN_TAG_UPLOAD_END_ERASE_FLASH:
			m_imgUpldProg.setCtx(ImgUploadStatus::EraseFlashEnd);
			emit imgUploadProgress(&m_imgUpldProg);
			break;
		case PLUGIN_TAG_UPLOAD_BLOCKS_START:
			m_imgUpldProg.setCtx(ImgUploadStatus::ImgUploadStart);
			m_imgUpldProg.setCbBlock(qs.toInt());
			emit imgUploadProgress(&m_imgUpldProg);
			break;
		case PLUGIN_TAG_UPLOAD_BLOCK:
			m_imgUpldProg.setCtx(ImgUploadStatus::ImgUploadBlock);
			if(parseTaggedValues(s.c_str(), nVal1, nVal2) == 2)
			{
				int nCbTotal = m_imgUpldProg.cbTotal();
				int nCbSent = nVal1;
				m_imgUpldProg.setCbSent(nCbSent);
				if(nCbTotal)
					m_imgUpldProg.setPercentSent(nCbSent * 100 / nCbTotal);
				m_imgUpldProg.SetBlockNr(nVal2);
				emit imgUploadProgress(&m_imgUpldProg);
			}
			break;
		case PLUGIN_TAG_UPLOAD_BLOCKS_END:
			m_imgUpldProg.setCtx(ImgUploadStatus::ImgUploadSuccess);
			m_imgUpldProg.setErrorCode(0);
			m_imgUpldProg.setUploadInProgress(false);
			emit imgUploadProgress(&m_imgUpldProg);
			break;
		case PLUGIN_TAG_UPLOAD_ERROR:
			m_imgUpldProg.setCtx(ImgUploadStatus::ImgUploadError);
			m_imgUpldProg.setErrorCode(qs.toInt());
			m_imgUpldProg.setUploadInProgress(false);
			emit imgUploadProgress(&m_imgUpldProg);
			break;
		}
	}
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

bool TivaFlash::getMatSer(int nSlvID, int nMbID)
{
	if(m_bExecuting)
		return false;
	if(!_IS_VALID_SLV_ID(nSlvID))
		return false;
	m_curSlvID = nSlvID;

	setMaterialEeprom(nSlvID, "");
	setSerialEeprom(nSlvID, "");

	QStringList args;
	args << "--show-mat-ser";
	args << QString::asprintf("--itf-name=%s", m_itfName.c_str());
	getSlavIDs(nSlvID, nMbID, args);
	getForceAllParities(args);
	args << "--plugin-mode";
	m_qProcess.start(QString::fromStdString(m_tivaFlashUtilPath), args, QIODevice::ReadOnly);
	return true;
}

bool TivaFlash::getTargetImgInfo(int nSlvID, int nMbID)
{
	if(m_bExecuting)
		return false;
	if(!_IS_VALID_SLV_ID(nSlvID))
		return false;
	m_curSlvID = nSlvID;

	setImgSizeBoot(nSlvID, 0);
	setImgCRC32Boot(nSlvID, 0.0);
	setImgMaterialBoot(nSlvID, "");
	setImgBuildBoot(nSlvID, "");

	setImgSizeApp(nSlvID, 0);
	setImgCRC32App(nSlvID, 0.0);
	setImgMaterialApp(nSlvID, "");
	setImgBuildApp(nSlvID, "");

	QStringList args;
	args << "--show-dev-img-info";
	args << QString::asprintf("--itf-name=%s", m_itfName.c_str());
	getSlavIDs(nSlvID, nMbID, args);
	getXBaud(args);
	getAppAddr(args);
	getForceAllParities(args);
	args << "--plugin-mode";
	m_qProcess.start(QString::fromStdString(m_tivaFlashUtilPath), args, QIODevice::ReadOnly);
	return true;
}

bool TivaFlash::pingTarget(int nSlvID, int nMbID)
{
	if(m_bExecuting)
		return false;
	if(!_IS_VALID_SLV_ID(nSlvID))
		return false;
	m_curSlvID = nSlvID;

	QStringList args;
	args << "--ping-target";
	args << QString::asprintf("--itf-name=%s", m_itfName.c_str());
	getSlavIDs(nSlvID, nMbID, args);
	getForceAllParities(args);
	args << "--plugin-mode";
	m_qProcess.start(QString::fromStdString(m_tivaFlashUtilPath), args, QIODevice::ReadOnly);
	return true;
}

bool TivaFlash::startBootloader(int nSlvID, int nMbID)
{
	if(m_bExecuting)
		return false;
	if(!_IS_VALID_SLV_ID(nSlvID))
		return false;
	m_curSlvID = nSlvID;

	QStringList args;
	args << "--start-boot";
	args << QString::asprintf("--itf-name=%s", m_itfName.c_str());
	getSlavIDs(nSlvID, nMbID, args);
	getForceAllParities(args);
	args << "--plugin-mode";
	m_qProcess.start(QString::fromStdString(m_tivaFlashUtilPath), args, QIODevice::ReadOnly);
	return true;
}

bool TivaFlash::resetBootloader(int nSlvID, int nMbID)
{
	if(m_bExecuting)
		return false;
	if(!_IS_VALID_SLV_ID(nSlvID))
		return false;
	m_curSlvID = nSlvID;

	QStringList args;
	args << "--reset-boot";
	args << QString::asprintf("--itf-name=%s", m_itfName.c_str());
	getSlavIDs(nSlvID, nMbID, args);
	getForceAllParities(args);
	args << "--plugin-mode";
	m_qProcess.start(QString::fromStdString(m_tivaFlashUtilPath), args, QIODevice::ReadOnly);
	return true;
}

bool TivaFlash::validateImgFile(int nSlvID, int nMbID)
{
	if(m_bExecuting)
		return false;
	if(!_IS_VALID_SLV_ID(nSlvID))
		return false;
	m_curSlvID = nSlvID;

	QStringList args;
	args << "--validate-img";
	args << QString::asprintf("--itf-name=%s", m_itfName.c_str());
	getSlavIDs(nSlvID, nMbID, args);
	getAppAddr(args);
	getForceAllParities(args);
	args << "--plugin-mode";
	args << QString::fromStdString(m_imgFile);
	m_qProcess.start(QString::fromStdString(m_tivaFlashUtilPath), args, QIODevice::ReadOnly);
	return true;
}

bool TivaFlash::uploadImgFile(int nSlvID, int nMbID)
{
	if(m_bExecuting)
		return false;
	if(!_IS_VALID_SLV_ID(nSlvID))
		return false;
	m_curSlvID = nSlvID;
	m_imgUpldProg.clear();

	QStringList args;
	args << "--upload-img";
	args << QString::asprintf("--itf-name=%s", m_itfName.c_str());
	getSlavIDs(nSlvID, nMbID, args);
	getXBaud(args);
	getAppAddr(args);
	getBlockSize(args);
	getPageEraseTime(args);
	getForceAllParities(args);
	args << "--plugin-mode";
	args << QString::fromStdString(m_imgFile);
	m_qProcess.start(QString::fromStdString(m_tivaFlashUtilPath), args, QIODevice::ReadOnly);
	return true;
}

bool TivaFlash::clearImgInfo(int nSlvID)
{
	if(m_bExecuting)
		return false;
	if(!_IS_VALID_SLV_ID(nSlvID))
		return false;

	setImgSizeFile(0);
	setImgCRC32File(0);
	setImgMaterialFile(0);
	setImgBuildFile(0);

	if(nSlvID > 0)
	{
		setMaterialEeprom(nSlvID, "");
		setSerialEeprom(nSlvID, "");

		setImgSizeBoot(nSlvID, 0);
		setImgCRC32Boot(nSlvID, 0);
		setImgMaterialBoot(nSlvID, "");
		setImgBuildBoot(nSlvID, "");

		setImgSizeApp(nSlvID, 0);
		setImgCRC32App(nSlvID, 0);
		setImgMaterialApp(nSlvID, "");
		setImgBuildApp(nSlvID, "");
	}
	else
	{
		for(int i = 0; i < _MAX_SLAVE_COUNT; ++i)
		{
			setMaterialEeprom(i, "");
			setSerialEeprom(i, "");

			setImgSizeBoot(i, 0);
			setImgCRC32Boot(i, 0);
			setImgMaterialBoot(i, "");
			setImgBuildBoot(i, "");

			setImgSizeApp(i, 0);
			setImgCRC32App(i, 0);
			setImgMaterialApp(i, "");
			setImgBuildApp(i, "");
		}
	}

	return true;
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

QString TivaFlash::tivaFlashUtilPath(void) const
{
	return QString::fromStdString(m_tivaFlashUtilPath);
}

void TivaFlash::setTivaFlashUtilPath(const QString &val)
{
	m_tivaFlashUtilPath = val.toStdString();
}

/////////////////////////////////////////////////////////////////////////////

QString TivaFlash::itfName(void) const
{
	return QString::fromStdString(m_itfName);
}

void TivaFlash::setItfName(const QString &val)
{
	m_itfName = val.toStdString();
}

/////////////////////////////////////////////////////////////////////////////

bool TivaFlash::slvIdIsNodeAddr(void) const
{
	return m_slvIdIsNodeAddr;
}

void TivaFlash::setSlvIdIsNodeAddr(bool val)
{
	if(m_slvIdIsNodeAddr != val)
	{
		m_slvIdIsNodeAddr = val;
	}
}

/////////////////////////////////////////////////////////////////////////////

int TivaFlash::verbosity(void) const
{
	return m_verbosity;
}

void TivaFlash::setVerbosity(int val)
{
	if(val < 0)
		val = 0;
	else if(val > 3)
		val = 3;

	if(m_verbosity != val)
	{
		m_verbosity = val;
	}
}

/////////////////////////////////////////////////////////////////////////////

QString TivaFlash::imgFile(void) const
{
	return QString::fromStdString(m_imgFile);
}

void TivaFlash::setImgFile(const QString &val)
{
	m_imgFile = val.toStdString();
}

/////////////////////////////////////////////////////////////////////////////

bool TivaFlash::executing(void) const
{
	return m_bExecuting;
}

void TivaFlash::setExecuting(bool val)
{
	if(m_bExecuting != val)
	{
		m_bExecuting = val;
		emit executingChanged(m_bExecuting);
	}
}

/////////////////////////////////////////////////////////////////////////////

int TivaFlash::xBaudRate(void) const
{
	return m_xBaudRate;
}

void TivaFlash::setXBaudRate(int val)
{
	if(m_xBaudRate != val)
	{
		m_xBaudRate = val;
	}
}

/////////////////////////////////////////////////////////////////////////////

int TivaFlash::appAddress(void) const
{
	return m_appAddress;
}

void TivaFlash::setAppAddress(int val)
{
	if(m_appAddress != val)
	{
		m_appAddress = val;
	}
}

/////////////////////////////////////////////////////////////////////////////

int TivaFlash::blockSize(void) const
{
	return m_blockSize;
}

void TivaFlash::setBlockSize(int val)
{
	if(m_blockSize != val)
	{
		m_blockSize = val;
	}
}

/////////////////////////////////////////////////////////////////////////////

int TivaFlash::pageEraseTime(void) const
{
	return m_pageEraseTime;
}

void TivaFlash::setPageEraseTime(int val)
{
	if(m_pageEraseTime != val)
	{
		m_pageEraseTime = val;
	}
}

/////////////////////////////////////////////////////////////////////////////

int TivaFlash::mbCtrlRegister(void) const
{
	return m_mbCtrlRegister;
}

void TivaFlash::setMbCtrlRegister(int val)
{
	if(m_mbCtrlRegister != val)
	{
		m_mbCtrlRegister = val;
	}
}

/////////////////////////////////////////////////////////////////////////////

bool TivaFlash::forceAllParities(void) const
{
	return m_forceAllParities;
}

void TivaFlash::setForceAllParities(bool val)
{
	if(m_forceAllParities != val)
	{
		m_forceAllParities = val;
	}
}

ImgUploadStatus* TivaFlash::imgUploadStatus(void)
{
	return &m_imgUpldProg;
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

const QStringList& TivaFlash::materialEeprom(void) const
{
	return m_materialEeprom;
}

void TivaFlash::setMaterialEeprom(int nSlvID, const QString &val)
{
	if(m_materialEeprom[nSlvID] != val)
	{
		m_materialEeprom[nSlvID] = val;
		emit materialEepromChanged();
	}
}

/////////////////////////////////////////////////////////////////////////////

const QStringList& TivaFlash::serialEeprom(void) const
{
	return m_serialEeprom;
}

void TivaFlash::setSerialEeprom(int nSlvID, const QString &val)
{
	if(m_serialEeprom[nSlvID] != val)
	{
		m_serialEeprom[nSlvID] = val;
		emit serialEepromChanged();
	}
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

const QList<int>& TivaFlash::imgSizeBoot(void) const
{
	return m_imgSizeBoot;
}

void TivaFlash::setImgSizeBoot(int nSlvID, int val)
{
	if(m_imgSizeBoot[nSlvID] != val)
	{
		m_imgSizeBoot[nSlvID] = val;
		emit imgSizeBootChanged();
	}
}

/////////////////////////////////////////////////////////////////////////////

const QList<double>& TivaFlash::imgCRC32Boot(void) const
{
	return m_imgCRC32Boot;
}

void TivaFlash::setImgCRC32Boot(int nSlvID, double val)
{
	if(m_imgCRC32Boot[nSlvID] != val)
	{
		m_imgCRC32Boot[nSlvID] = val;
		emit imgCRC32BootChanged();
	}
}

/////////////////////////////////////////////////////////////////////////////

const QStringList& TivaFlash::imgMaterialBoot(void) const
{
	return m_imgMaterialBoot;
}

void TivaFlash::setImgMaterialBoot(int nSlvID, const QString &val)
{
	if(m_imgMaterialBoot[nSlvID] != val)
	{
		m_imgMaterialBoot[nSlvID] = val;
		emit imgMaterialBootChanged();
	}
}

/////////////////////////////////////////////////////////////////////////////

const QStringList& TivaFlash::imgBuildBoot(void) const
{
	return m_imgBuildBoot;
}

void TivaFlash::setImgBuildBoot(int nSlvID, const QString &val)
{
	if(m_imgBuildBoot[nSlvID] != val)
	{
		m_imgBuildBoot[nSlvID] = val;
		emit imgBuildBootChanged();
	}
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

const QList<int>& TivaFlash::imgSizeApp(void) const
{
	return m_imgSizeApp;
}

void TivaFlash::setImgSizeApp(int nSlvID, int val)
{
	if(m_imgSizeApp[nSlvID] != val)
	{
		m_imgSizeApp[nSlvID] = val;
		emit imgSizeAppChanged();
	}
}

/////////////////////////////////////////////////////////////////////////////

const QList<double>& TivaFlash::imgCRC32App(void) const
{
	return m_imgCRC32App;
}

void TivaFlash::setImgCRC32App(int nSlvID, double val)
{
	if(m_imgCRC32App[nSlvID] != val)
	{
		m_imgCRC32App[nSlvID] = val;
		emit imgCRC32AppChanged();
	}
}

/////////////////////////////////////////////////////////////////////////////

const QStringList& TivaFlash::imgMaterialApp(void) const
{
	return m_imgMaterialApp;
}

void TivaFlash::setImgMaterialApp(int nSlvID, const QString &val)
{
	if(m_imgMaterialApp[nSlvID] != val)
	{
		m_imgMaterialApp[nSlvID] = val;
		emit imgMaterialAppChanged();
	}
}

/////////////////////////////////////////////////////////////////////////////

const QStringList& TivaFlash::imgBuildApp(void) const
{
	return m_imgBuildApp;
}

void TivaFlash::setImgBuildApp(int nSlvID, const QString &val)
{
	if(m_imgBuildApp[nSlvID] != val)
	{
		m_imgBuildApp[nSlvID] = val;
		emit imgBuildAppChanged();
	}
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

int TivaFlash::imgSizeFile(void) const
{
	return m_imgSizeFile;
}

void TivaFlash::setImgSizeFile(int val)
{
	if(m_imgSizeFile != val)
	{
		m_imgSizeFile = val;
		emit imgSizeFileChanged(m_imgSizeFile);
	}
}

/////////////////////////////////////////////////////////////////////////////

double TivaFlash::imgCRC32File(void) const
{
	return m_imgCRC32File;
}

void TivaFlash::setImgCRC32File(double val)
{
	if(m_imgCRC32File != val)
	{
		m_imgCRC32File = val;
		emit imgCRC32FileChanged(m_imgCRC32File);
	}
}

/////////////////////////////////////////////////////////////////////////////

const QString& TivaFlash::imgMaterialFile(void) const
{
	return m_imgMaterialFile;
}

void TivaFlash::setImgMaterialFile(const QString &val)
{
	if(m_imgMaterialFile != val)
	{
		m_imgMaterialFile = val;
		emit materialFileChanged(m_imgMaterialFile);
	}
}

/////////////////////////////////////////////////////////////////////////////

const QString& TivaFlash::imgBuildFile(void) const
{
	return m_imgBuildFile;
}

void TivaFlash::setImgBuildFile(const QString &val)
{
	if(m_imgBuildFile != val)
	{
		m_imgBuildFile = val;
		emit imgBuildFileChanged(m_imgBuildFile);
	}
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

ImgUploadStatus::ImgUploadStatus(QObject *pParent) :	QObject(pParent)
{
	setObjectName("ImgUploadStatus");
	clear();
}

ImgUploadStatus::~ImgUploadStatus(void)
{
}

/////////////////////////////////////////////////////////////////////////////

void ImgUploadStatus::clear(void)
{
	m_nCtx = 0;
	m_nErrorCode = 0;
	m_nCbBlock = 0;
	m_nBlockNr = 0;
	m_nCbTotal = 0;
	m_nCbSent = 0;
	m_nPercentSent = 0;
	m_nCntFlashPages = 0;
	m_bUploadInProgress = false;
}

/////////////////////////////////////////////////////////////////////////////

int ImgUploadStatus::ctx(void) const
{
	return m_nCtx;
}

void ImgUploadStatus::setCtx(int val)
{
	if(m_nCtx != val)
	{
		m_nCtx = val;
		emit ctxChanged(m_nCtx);
	}
}

/////////////////////////////////////////////////////////////////////////////

int ImgUploadStatus::errorCode(void) const
{
	return m_nErrorCode;
}

void ImgUploadStatus::setErrorCode(int val)
{
	if(m_nErrorCode != val)
	{
		m_nErrorCode = val;
		emit errorCodeChanged(m_nErrorCode);
	}
}

/////////////////////////////////////////////////////////////////////////////

int ImgUploadStatus::cbBlock(void) const
{
	return m_nCbBlock;
}

void ImgUploadStatus::setCbBlock(int val)
{
	if(m_nCbBlock != val)
	{
		m_nCbBlock = val;
		emit cbBlockChanged(m_nCbBlock);
	}
}

/////////////////////////////////////////////////////////////////////////////

int ImgUploadStatus::blockNr(void) const
{
	return m_nBlockNr;
}

void ImgUploadStatus::SetBlockNr(int val)
{
	if(m_nBlockNr != val)
	{
		m_nBlockNr = val;
		emit blockNrChanged(m_nBlockNr);
	}
}

/////////////////////////////////////////////////////////////////////////////

int ImgUploadStatus::cbTotal(void) const
{
	return m_nCbTotal;
}

void ImgUploadStatus::setCbTotal(int val)
{
	if(m_nCbTotal != val)
	{
		m_nCbTotal = val;
		emit cbTotalChanged(m_nCbTotal);
	}
}

/////////////////////////////////////////////////////////////////////////////

int ImgUploadStatus::cbSent(void) const
{
	return m_nCbSent;
}

void ImgUploadStatus::setCbSent(int val)
{
	if(m_nCbSent != val)
	{
		m_nCbSent = val;
		emit cbSentChanged(m_nCbSent);
	}
}

/////////////////////////////////////////////////////////////////////////////

int ImgUploadStatus::percentSent(void) const
{
	return m_nPercentSent;
}

void ImgUploadStatus::setPercentSent(int val)
{
	if(m_nPercentSent != val)
	{
		m_nPercentSent = val;
		emit percentSentChanged(m_nPercentSent);
	}
}

/////////////////////////////////////////////////////////////////////////////

int ImgUploadStatus::cntFlashPages(void) const
{
	return m_nCntFlashPages;
}

void ImgUploadStatus::setCntFlashPages(int val)
{
	if(m_nCntFlashPages != val)
	{
		m_nCntFlashPages = val;
		emit cntFlashPagesChanged(m_nCntFlashPages);
	}
}

/////////////////////////////////////////////////////////////////////////////

bool ImgUploadStatus::uploadInProgress(void) const
{
	return m_bUploadInProgress;
}

void ImgUploadStatus::setUploadInProgress(bool val)
{
	if(m_bUploadInProgress != val)
	{
		m_bUploadInProgress = val;
		emit uploadInProgressChanged(m_bUploadInProgress);
	}
}