Testversion noch ohne File-Upload.

cmdopt.c

@@ -54,6 +54,7 @@
 #define _OV_HAS_MODBUS_SLAVE_ID					((uint32_t)0x02000000)
 #define _OV_HAS_MODBUS_CTRL_REG					((uint32_t)0x04000000)
 #define _OV_HAS_FORCE_ALL_PARITIES				((uint32_t)0x08000000)
+#define _OV_HAS_PLUGIN_MODE						((uint32_t)0x10000000)
 
 /////////////////////////////////////////////////////////////////////////////
 
@@ -79,16 +80,16 @@
 
 #define _OPT_CONNECTION_OPTS					(_OV_HAS_STATION_NUMBER | _OV_HAS_NODE_ADDR | _OV_HAS_MODBUS_SLAVE_ID | _OV_HAS_MODBUS_CTRL_REG | _OV_HAS_FORCE_ALL_PARITIES)
 
-#define _OPT_OPTS_UPLOAD_IMG					(_OPT_CONNECTION_OPTS | _OV_HAS_IMG_FILE | _OV_HAS_APP_ADDR | _OV_HAS_X_BAUD_RATE | _OV_HAS_NO_SHOW_PROGRESS | _OV_HAS_PAGE_ERASE_TIME | _OV_HAS_BLOCK_SIZE)
-#define _OPT_OPTS_SHOW_IMG_INFO_OFFLINE			_OV_HAS_APP_ADDR
-#define _OPT_OPTS_SHOW_IMG_INFO_ONLINE			(_OPT_CONNECTION_OPTS | _OV_HAS_X_BAUD_RATE | _OV_HAS_APP_ADDR)
-#define _OPT_OPTS_VALIDATE_IMG					(_OPT_CONNECTION_OPTS | _OV_HAS_APP_ADDR)
-#define _OPT_OPTS_SHOW_MAT_SER					(_OPT_CONNECTION_OPTS)
-#define _OPT_OPTS_SET_MAT_SER					(_OPT_CONNECTION_OPTS)
-#define _OPT_OPTS_BOOT_PING						(_OPT_CONNECTION_OPTS | _OV_HAS_PING_INTERVAL)
-#define _OPT_OPTS_START_BOOT					_OPT_CONNECTION_OPTS
-#define _OPT_OPTS_RESET_BOOT					_OPT_CONNECTION_OPTS
-#define _OPT_OPTS_RESCUE_BOOT					_OPT_CONNECTION_OPTS
+#define _OPT_OPTS_UPLOAD_IMG					(_OPT_CONNECTION_OPTS | _OV_HAS_IMG_FILE | _OV_HAS_APP_ADDR | _OV_HAS_X_BAUD_RATE | _OV_HAS_NO_SHOW_PROGRESS | _OV_HAS_PAGE_ERASE_TIME | _OV_HAS_BLOCK_SIZE | _OV_HAS_PLUGIN_MODE)
+#define _OPT_OPTS_SHOW_IMG_INFO_OFFLINE			(_OV_HAS_APP_ADDR | _OV_HAS_PLUGIN_MODE)
+#define _OPT_OPTS_SHOW_IMG_INFO_ONLINE			(_OPT_CONNECTION_OPTS | _OV_HAS_X_BAUD_RATE | _OV_HAS_APP_ADDR | _OV_HAS_PLUGIN_MODE)
+#define _OPT_OPTS_VALIDATE_IMG					(_OPT_CONNECTION_OPTS | _OV_HAS_APP_ADDR | _OV_HAS_PLUGIN_MODE)
+#define _OPT_OPTS_SHOW_MAT_SER					(_OPT_CONNECTION_OPTS | _OV_HAS_PLUGIN_MODE)
+#define _OPT_OPTS_SET_MAT_SER					(_OPT_CONNECTION_OPTS | _OV_HAS_PLUGIN_MODE)
+#define _OPT_OPTS_BOOT_PING						(_OPT_CONNECTION_OPTS | _OV_HAS_PING_INTERVAL | _OV_HAS_PLUGIN_MODE)
+#define _OPT_OPTS_START_BOOT					(_OPT_CONNECTION_OPTS | _OV_HAS_PLUGIN_MODE)
+#define _OPT_OPTS_RESET_BOOT					(_OPT_CONNECTION_OPTS | _OV_HAS_PLUGIN_MODE)
+#define _OPT_OPTS_RESCUE_BOOT					(_OPT_CONNECTION_OPTS | _OV_HAS_PLUGIN_MODE)
 
 /////////////////////////////////////////////////////////////////////////////
 
@@ -128,6 +129,7 @@
 #define _OPT_STRING_MODBUS_SLAVE_ID				"mb-slave-id"
 #define _OPT_STRING_MODBUS_CTRL_REG				"mb-bl-ctrl-reg"
 #define _OPT_STRING_FORCE_ALL_PARITIES			"force-all-par"
+#define _OPT_STRING_PLUGIN_MODE					"plugin-mode"
 #define _OPT_STRING_VERBOSITY					"verbosity"
 #define _OPT_STRING_HELP						"help"
 #define _OPT_STRING_IMG_FILE					"<IMG FILE>"
@@ -138,6 +140,7 @@
 /////////////////////////////////////////////////////////////////////////////
 
 int g_nVerbosity = CMD_OPT_DEFAULT_VERBOSITY;
+bool g_bPluginMode = false;
 
 /////////////////////////////////////////////////////////////////////////////
 
@@ -214,6 +217,8 @@ static const char* _GetOptName(uint32_t nOpt)
 		return _OPT_STRING_MODBUS_CTRL_REG;
 	case _OV_HAS_FORCE_ALL_PARITIES:
 		return _OPT_STRING_FORCE_ALL_PARITIES;
+	case _OV_HAS_PLUGIN_MODE:
+		return _OPT_STRING_PLUGIN_MODE;
 	default:
 		return NULL;
 	}
@@ -285,6 +290,8 @@ static const char* _GetOptValue(uint32_t nOpt, LPCMD_LINE_ARGS pcla)
 		break;
 	case _OV_HAS_FORCE_ALL_PARITIES:
 		return "true";
+	case _OV_HAS_PLUGIN_MODE:
+		return "true";
 	default:
 		return "empty";
 	}
@@ -475,6 +482,12 @@ static const struct option g_lo[] =
 		NULL,
 		ov_force_all_par
 	},
+	{
+		_OPT_STRING_PLUGIN_MODE,
+		no_argument,
+		NULL,
+		ov_plugin_mode
+	},
 	{
 		_OPT_STRING_VERBOSITY,
 		required_argument,
@@ -660,6 +673,10 @@ int GfaTfuCmdOptParse(int argc, char* argv[], LPCMD_LINE_ARGS pcla)
 			pcla->bForceAllParities = true;
 			pcla->nOptFlags |= _OV_HAS_FORCE_ALL_PARITIES;
 			break;
+		case ov_plugin_mode:
+			pcla->bPluginMode = true;
+			pcla->nOptFlags |= _OV_HAS_PLUGIN_MODE;
+			break;
 		case ov_verbosity:
 			pcla->nVerbosity = (int)_ArgStr2Num(arg, CMD_OPT_DEFAULT_VERBOSITY);
 			break;
@@ -697,6 +714,15 @@ int GfaTfuCmdOptProcess(LPCMD_LINE_ARGS pcla)
 		pcla->nVerbosity = CMD_OPT_MAX_VERBOSITY;
 	g_nVerbosity = pcla->nVerbosity;
 
+	/////////////////////////////////////////////////////////////////////////
+	// if we are in plugin-mode we produce formatted output only
+	
+	if(pcla->bPluginMode)
+	{
+		g_nVerbosity = pcla->nVerbosity = -1;
+		g_bPluginMode = true;
+	}
+
 	/////////////////////////////////////////////////////////////////////////
 	// validate commands
 

cmdopt.h

@@ -39,6 +39,7 @@ typedef enum _OptValues
 	ov_start_boot,
 	ov_reset_boot,
 	ov_rescue_boot,
+	ov_plugin_mode,
 	ov_mb_slave_id,
 	ov_mb_ctrl_reg,
 	ov_app_addr			= 'a',
@@ -78,6 +79,7 @@ typedef struct _CMD_LINE_ARGS
 	bool bNeedImgFile;
 	bool bNoProgressBlock;
 	bool bForceAllParities;
+	bool bPluginMode;
 	uint8_t modbParity;
 	int16_t nModbusCtrlReg;
 	int nQuestionMarks;

main.c

@@ -52,11 +52,44 @@ static int _ShowDevImgInfo(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla, GF
 	UNUSED(hIf);
 
 	TRACE3("Getting image information.\n");
+	TTRACE3("Getting image information");
 
     if((ctx == GfaBlmCtx_App) && ((nRet = GfaBlmGetInfoBI(hBlm, pcla->nNodeAddr, &aii)) == 0))
     {
     	GfaTfuDumpImageInfo("Bootloader", &aii.bl);
     	GfaTfuDumpImageInfo("Application", &aii.app);
+
+		if(	(aii.bl.nImgLength != 0xFFFFFFFF) &&
+			(aii.bl.nImgCRC32 != 0xFFFFFFFF))
+		{
+			TTRACE(PLUGIN_TAG_IMG_LENGTH_BOOT, "%u", aii.bl.nImgLength);
+			TTRACE(PLUGIN_TAG_IMG_CRC32_BOOT, "%u", aii.bl.nImgCRC32);
+			TTRACE(PLUGIN_TAG_IMG_MATERIAL_BOOT, "%s", aii.bl.szImgMaterialNum);
+			TTRACE(PLUGIN_TAG_IMG_BUILD_BOOT, "%s", aii.bl.szImgNameBuild);
+		}
+		else
+		{
+			TTRACE(PLUGIN_TAG_IMG_LENGTH_BOOT, "%u", 0xFFFFFFFF);
+			TTRACE(PLUGIN_TAG_IMG_CRC32_BOOT, "%u", 0xFFFFFFFF);
+			TTRACE(PLUGIN_TAG_IMG_MATERIAL_BOOT, "%s", "n/a");
+			TTRACE(PLUGIN_TAG_IMG_BUILD_BOOT, "%s", "n/a");
+		}
+
+		if(	(aii.app.nImgLength != 0xFFFFFFFF) &&
+			(aii.app.nImgCRC32 != 0xFFFFFFFF))
+		{
+			TTRACE(PLUGIN_TAG_IMG_LENGTH_APP, "%u", aii.app.nImgLength);
+			TTRACE(PLUGIN_TAG_IMG_CRC32_APP, "%u", aii.app.nImgCRC32);
+			TTRACE(PLUGIN_TAG_IMG_MATERIAL_APP, "%s", aii.app.szImgMaterialNum);
+			TTRACE(PLUGIN_TAG_IMG_BUILD_APP, "%s", aii.app.szImgNameBuild);
+		}
+		else
+		{
+			TTRACE(PLUGIN_TAG_IMG_LENGTH_APP, "%u", 0xFFFFFFFF);
+			TTRACE(PLUGIN_TAG_IMG_CRC32_APP, "%u", 0xFFFFFFFF);
+			TTRACE(PLUGIN_TAG_IMG_MATERIAL_APP, "%s", "n/a");
+			TTRACE(PLUGIN_TAG_IMG_BUILD_APP, "%s", "n/a");
+		}
     }
     else
 	{
@@ -66,10 +99,13 @@ static int _ShowDevImgInfo(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla, GF
 		{
 			TRACE3("Application doesn't recognize BI command!\n");
 			TRACE3("Starting bootloader.\n");
+			TTRACE3("Application doesn't recognize BI command");
+			TTRACE3("Starting bootloader");
 
 			if((nRet = GfaBlmBootloaderExecute(hBlm, pcla->nNodeAddr, NULL, 1000)) != 0)
 			{
 				TRACE1("Error: %s!\n", GfaTfuStrError(errno));
+				TTRACE1(GfaTfuStrError(errno));
 				return nRet;
 			}
 
@@ -79,10 +115,12 @@ static int _ShowDevImgInfo(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla, GF
         if(pcla->nExBaudrate != pcla->nInitBaudrate)
         {
 			TRACE3("Setting baud-rate to %u.\n", pcla->nExBaudrate);
+			TTRACE3("Setting baud-rate to %u", pcla->nExBaudrate);
 
 			if((nRet = GfaBlmBootloaderSetBaudrate(hBlm, pcla->nNodeAddr, pcla->nExBaudrate)) != 0)
 			{
 				TRACE1("Error: %s!\n", GfaTfuStrError(errno));
+				TTRACE1(GfaTfuStrError(errno));
 				return nRet;
 	        }
         }
@@ -91,20 +129,55 @@ static int _ShowDevImgInfo(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla, GF
 		{
 	    	GfaTfuDumpImageInfo("Bootloader", &aii.bl);
 	    	GfaTfuDumpImageInfo("Application", &aii.app);
+
+			if(	(aii.bl.nImgLength != 0xFFFFFFFF) &&
+				(aii.bl.nImgCRC32 != 0xFFFFFFFF))
+			{
+				TTRACE(PLUGIN_TAG_IMG_LENGTH_BOOT, "%u", aii.bl.nImgLength);
+				TTRACE(PLUGIN_TAG_IMG_CRC32_BOOT, "%u", aii.bl.nImgCRC32);
+				TTRACE(PLUGIN_TAG_IMG_MATERIAL_BOOT, "%s", aii.bl.szImgMaterialNum);
+				TTRACE(PLUGIN_TAG_IMG_BUILD_BOOT, "%s", aii.bl.szImgNameBuild);
+			}
+			else
+			{
+				TTRACE(PLUGIN_TAG_IMG_LENGTH_BOOT, "%u", 0xFFFFFFFF);
+				TTRACE(PLUGIN_TAG_IMG_CRC32_BOOT, "%u", 0xFFFFFFFF);
+				TTRACE(PLUGIN_TAG_IMG_MATERIAL_BOOT, "%s", "n/a");
+				TTRACE(PLUGIN_TAG_IMG_BUILD_BOOT, "%s", "n/a");
+			}
+
+			if(	(aii.app.nImgLength != 0xFFFFFFFF) &&
+				(aii.app.nImgCRC32 != 0xFFFFFFFF))
+			{
+				TTRACE(PLUGIN_TAG_IMG_LENGTH_APP, "%u", aii.app.nImgLength);
+				TTRACE(PLUGIN_TAG_IMG_CRC32_APP, "%u", aii.app.nImgCRC32);
+				TTRACE(PLUGIN_TAG_IMG_MATERIAL_APP, "%s", aii.app.szImgMaterialNum);
+				TTRACE(PLUGIN_TAG_IMG_BUILD_APP, "%s", aii.app.szImgNameBuild);
+			}
+			else
+			{
+				TTRACE(PLUGIN_TAG_IMG_LENGTH_APP, "%u", 0xFFFFFFFF);
+				TTRACE(PLUGIN_TAG_IMG_CRC32_APP, "%u", 0xFFFFFFFF);
+				TTRACE(PLUGIN_TAG_IMG_MATERIAL_APP, "%s", "n/a");
+				TTRACE(PLUGIN_TAG_IMG_BUILD_APP, "%s", "n/a");
+			}
 	    }
 	    else
 	    {
 			TRACE1("Error: %s!\n", GfaTfuStrError(errno));
+			TTRACE1(GfaTfuStrError(errno));
 			return nRet;
 	    }
 
         if(pcla->nExBaudrate != pcla->nInitBaudrate)
         {
 			TRACE3("Setting baud-rate to %u.\n", pcla->nInitBaudrate);
+			TTRACE3("Setting baud-rate to %u", pcla->nInitBaudrate);
 
 			if((nRet = GfaBlmBootloaderSetBaudrate(hBlm, pcla->nNodeAddr, pcla->nInitBaudrate)) != 0)
 			{
 				TRACE1("Error: %s!\n", GfaTfuStrError(errno));
+				TTRACE1(GfaTfuStrError(errno));
 				return nRet;
 	        }
         }
@@ -112,10 +185,12 @@ static int _ShowDevImgInfo(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla, GF
         if(bStartApp)
         {
 			TRACE3("Starting application.\n");
+			TTRACE3("Starting application");
 
             if((nRet = GfaBlmBUCmdReset(hBlm, pcla->nNodeAddr, pcla->nInitBaudrate)) != 0)
 	        {
 				TRACE1("Error: %s!\n", GfaTfuStrError(errno));
+				TTRACE1(GfaTfuStrError(errno));
 				return nRet;
 	        }
         }
@@ -134,25 +209,39 @@ static int _ValidateImg(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla, GFA_B
 	UNUSED(ctx);
 
 	TRACE3("Reading material number.\n");
+	TTRACE3("Reading material number");
 
 	if((nRet = GfaBlmReadMaterialAndSerialID(hBlm, pcla->nNodeAddr, szMaterial, sizeof(szMaterial), szSerial, sizeof(szSerial))) != 0)
 	{
 		TRACE1("Error: %s!\n", GfaTfuStrError(errno));
+		TTRACE1(GfaTfuStrError(errno));
 		return nRet;
 	}
 
+	if(szMaterial[0] == '\xFF')
+		strcpy(szMaterial, "not set");
+	if(szSerial[0] == '\xFF')
+		strcpy(szSerial, "not set");
+
+	TTRACE(PLUGIN_TAG_IMG_MATERIAL_EEPROM, szMaterial);
+	TTRACE(PLUGIN_TAG_IMG_SERIAL_EEPROM, szSerial);
+
 	GfaTfuImageFileGetInfo(hIf, &ii);
 
 	TRACE2("Material number target: \"%s\"\n", szMaterial);
 	TRACE2("Material number file:   \"%s\"\n", ii.szImgMaterialNum);
+	TTRACE2("Material number target: \"%s\"", szMaterial);
+	TTRACE2("Material number file:   \"%s\"", ii.szImgMaterialNum);
 
 	if(!GfaTfuImageFileMatchMaterialNum(hIf, szMaterial))
 	{
 		TRACE1("Error: %s!\n", GfaTfuStrError(errno));
+		TTRACE1(GfaTfuStrError(errno));
 		return -1;
 	}
 
 	TRACE2("\"%s\" - Image is valid for target @ node 0x%02hhX!\n", pcla->pszImgFileBase, pcla->nNodeAddr);
+	TTRACE2("\"%s\" - Image is valid for target @ node 0x%02hhX", pcla->pszImgFileBase, pcla->nNodeAddr);
 	return 0;
 }
 
@@ -166,10 +255,12 @@ static int _ShowMatSer(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla, GFA_BL
 	UNUSED(ctx);
 
 	TRACE3("Reading material and serial number.\n");
+	TTRACE3("Reading material and serial number");
 
 	if((nRet = GfaBlmReadMaterialAndSerialID(hBlm, pcla->nNodeAddr, szMaterial, sizeof(szMaterial), szSerial, sizeof(szSerial))) != 0)
 	{
 		TRACE1("Error: %s!\n", GfaTfuStrError(errno));
+		TTRACE1(GfaTfuStrError(errno));
 		return nRet;
 	}
 
@@ -181,6 +272,8 @@ static int _ShowMatSer(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla, GFA_BL
 	TRACE2("Material and Serial number:\n");
 	TRACE2("  Mat.Nr.: \"%s\"\n", szMaterial);
 	TRACE2("  Serial:  \"%s\"\n", szSerial);
+	TTRACE(PLUGIN_TAG_IMG_MATERIAL_EEPROM, szMaterial);
+	TTRACE(PLUGIN_TAG_IMG_SERIAL_EEPROM, szSerial);
 	return nRet;
 }
 
@@ -198,6 +291,7 @@ static int _SetMatSer(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla, GFA_BLM
 		if((nRet = GfaBlmBootloaderExecute(hBlm, pcla->nNodeAddr, NULL, 1000)) != 0)
 		{
 			TRACE1("Error: %s!\n", GfaTfuStrError(errno));
+			TTRACE1(GfaTfuStrError(errno));
 			return nRet;
 		}
 
@@ -211,6 +305,7 @@ static int _SetMatSer(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla, GFA_BLM
 	if((nRet = GfaBlmWriteMaterialAndSerialID(hBlm, pcla->nNodeAddr, pcla->pszMaterial, pcla->pszSerial)) != 0)
 	{
 		TRACE1("Error: %s!\n", GfaTfuStrError(errno));
+		TTRACE1(GfaTfuStrError(errno));
 		return nRet;
 	}
 
@@ -223,6 +318,7 @@ static int _SetMatSer(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla, GFA_BLM
         if((nRet = GfaBlmBUCmdReset(hBlm, pcla->nNodeAddr, pcla->nInitBaudrate)) != 0)
         {
 			TRACE1("Error: %s!\n", GfaTfuStrError(errno));
+			TTRACE1(GfaTfuStrError(errno));
 			return nRet;
         }
     }
@@ -281,10 +377,12 @@ static int _Ping(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla, GFA_BLM_EXEC
 				GfaTfuGetClock(&tsEnd);
 				nIntervalModB = GfaTfuClockDiff(&tsEnd, &tsStart);
 				TRACE2("Slave 0x%02hhX [%s] ping success [%.1f ms] - %s.\n", pcla->nModbusSlvID, _ABBR_MODBUS, (double)nIntervalModB / 1000000.0, szTime);
+				TTRACE2("Slave 0x%02hhX [%s] ping success [%.1f ms] - %s", pcla->nModbusSlvID, _ABBR_MODBUS, (double)nIntervalModB / 1000000.0, szTime);
 			}
 			else
 			{
 				TRACE1("Slave 0x%02hhX [%s] ping error: %s - %s.\n", pcla->nModbusSlvID, _ABBR_MODBUS, GfaTfuStrError(errno), szTime);
+				TTRACE1("Slave 0x%02hhX [%s] ping error: %s - %s", pcla->nModbusSlvID, _ABBR_MODBUS, GfaTfuStrError(errno), szTime);
 			}
 		}
 		else if((nRet = GfaBlmMininetPing(hBlm, pcla->nNodeAddr)) == 0)
@@ -303,12 +401,14 @@ static int _Ping(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla, GFA_BLM_EXEC
 						if((nRet = GfaBlmResetSlaveIndex(hBlm, pcla->nNodeAddr)) != 0)
 				        {
 							TRACE1("Node 0x%02hhX [%s] ping error: %s - %s.\n", pcla->nNodeAddr, (ctx == GfaBlmCtx_Boot) ? _ABBR_BOOTLOADER : _ABBR_APPLICATION, GfaTfuStrError(errno), szTime);
+							TTRACE1("Node 0x%02hhX [%s] ping error: %s - %s", pcla->nNodeAddr, (ctx == GfaBlmCtx_Boot) ? _ABBR_BOOTLOADER : _ABBR_APPLICATION, GfaTfuStrError(errno), szTime);
 							break;
 				        }
 
 				        if((ctx = GfaBlmGetExecutionContext(hBlm, pcla->nNodeAddr)) == GfaBlmCtx_Err)
 				        {
 							TRACE1("Node 0x%02hhX ping error: %s - %s.\n", pcla->nNodeAddr, GfaTfuStrError(errno), szTime);
+							TTRACE1("Node 0x%02hhX ping error: %s - %s", pcla->nNodeAddr, GfaTfuStrError(errno), szTime);
 							break;
 				        }
 
@@ -326,11 +426,14 @@ static int _Ping(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla, GFA_BLM_EXEC
 				GfaTfuGetClock(&tsEnd);
 				nIntervalBoot = GfaTfuClockDiff(&tsEnd, &tsStart);
 				TRACE2("Node 0x%02hhX [%s] ping success [%.1f ms] - %s.\n", pcla->nNodeAddr, (ctx == GfaBlmCtx_Boot) ? _ABBR_BOOTLOADER : _ABBR_APPLICATION, (double)nIntervalBoot / 1000000.0, szTime);
+				TTRACE2("Node 0x%02hhX [%s] ping success [%.1f ms] - %s", pcla->nNodeAddr, (ctx == GfaBlmCtx_Boot) ? _ABBR_BOOTLOADER : _ABBR_APPLICATION, (double)nIntervalBoot / 1000000.0, szTime);
 			}
 			else
 			{
 				TRACE2("Node 0x%02hhX [%s] ping success [%.1f ms] - %s.\n", pcla->nNodeAddr, _ABBR_MININET, (double)nIntervalMini / 1000000.0, szTime);
+				TTRACE2("Node 0x%02hhX [%s] ping success [%.1f ms] - %s", pcla->nNodeAddr, _ABBR_MININET, (double)nIntervalMini / 1000000.0, szTime);
 				TRACE1("Node 0x%02hhX [%s] ping error: %s - %s.\n", pcla->nNodeAddr, (ctx == GfaBlmCtx_Boot) ? _ABBR_BOOTLOADER : _ABBR_APPLICATION, GfaTfuStrError(errno), szTime);
+				TTRACE1("Node 0x%02hhX [%s] ping error: %s - %s", pcla->nNodeAddr, (ctx == GfaBlmCtx_Boot) ? _ABBR_BOOTLOADER : _ABBR_APPLICATION, GfaTfuStrError(errno), szTime);
 			}
 		}
 		else
@@ -340,6 +443,7 @@ static int _Ping(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla, GFA_BLM_EXEC
 				if((nRet = GfaBlmResetSlaveIndex(hBlm, pcla->nNodeAddr)) != 0)
 		        {
 					TRACE1("Node 0x%02hhX [%s] ping error: %s - %s.\n", pcla->nNodeAddr, (ctx == GfaBlmCtx_Boot) ? _ABBR_BOOTLOADER : _ABBR_APPLICATION, GfaTfuStrError(errno), szTime);
+					TTRACE1("Node 0x%02hhX [%s] ping error: %s - %s", pcla->nNodeAddr, (ctx == GfaBlmCtx_Boot) ? _ABBR_BOOTLOADER : _ABBR_APPLICATION, GfaTfuStrError(errno), szTime);
 					break;
 		        }
 
@@ -347,6 +451,7 @@ static int _Ping(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla, GFA_BLM_EXEC
 		    }
 
 			TRACE1("Node 0x%02hhX [%s] ping error: %s - %s.\n", pcla->nNodeAddr, _ABBR_MININET, GfaTfuStrError(errno), szTime);
+			TTRACE1("Node 0x%02hhX [%s] ping error: %s - %s", pcla->nNodeAddr, _ABBR_MININET, GfaTfuStrError(errno), szTime);
 		}
 
 		if(pcla->nPingIntervalSec > 0)
@@ -386,6 +491,7 @@ static int _UploadImg(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla, GFA_BLM
 			if((nRet = GfaBlmBootloaderExecute(hBlm, pcla->nNodeAddr, NULL, 1000)) != 0)
 			{
 				TRACE1("Error: %s!\n", GfaTfuStrError(errno));
+				TTRACE1(GfaTfuStrError(errno));
 				return nRet;
 			}
 		}
@@ -397,6 +503,7 @@ static int _UploadImg(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla, GFA_BLM
 			if((nRet = GfaBlmBootloaderSetBaudrate(hBlm, pcla->nNodeAddr, pcla->nExBaudrate)) != 0)
 			{
 				TRACE1("Error: %s!\n", GfaTfuStrError(errno));
+				TTRACE1(GfaTfuStrError(errno));
 				return nRet;
 	        }
         }
@@ -416,6 +523,7 @@ static int _UploadImg(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla, GFA_BLM
 					if((nRet = GfaBlmBootloaderSetBaudrate(hBlm, pcla->nNodeAddr, pcla->nBootBaudrate)) != 0)
 					{
 						TRACE1("Error: %s!\n", GfaTfuStrError(errno));
+						TTRACE1(GfaTfuStrError(errno));
 			        }
 		        }
 
@@ -431,6 +539,7 @@ static int _UploadImg(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla, GFA_BLM
 				if((nRet = GfaBlmBootloaderSetBaudrate(hBlm, pcla->nNodeAddr, pcla->nBootBaudrate)) != 0)
 				{
 					TRACE1("Error: %s!\n", GfaTfuStrError(errno));
+					TTRACE1(GfaTfuStrError(errno));
 		        }
 	        }
 
@@ -442,6 +551,7 @@ static int _UploadImg(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla, GFA_BLM
         if((nRet = GfaBlmBUCmdReset(hBlm, pcla->nNodeAddr, pcla->nInitBaudrate)) != 0)
         {
 			TRACE1("Error: %s!\n", GfaTfuStrError(errno));
+			TTRACE1(GfaTfuStrError(errno));
 			return nRet;
         }
 	}
@@ -459,14 +569,17 @@ static int _ResetBootloader(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla, G
 	if(ctx == GfaBlmCtx_App)
 	{
 		TRACE2("Application already executing!\n");
+		TTRACE2("Application already executing");
 		return 0; // no error
 	}
 
 	TRACE3("Resetting bootloader.\n");
+	TTRACE3("Resetting bootloader");
 
     if((nRet = GfaBlmBUCmdReset(hBlm, pcla->nNodeAddr, pcla->nInitBaudrate)) != 0)
     {
 		TRACE1("Error: %s!\n", GfaTfuStrError(errno));
+		TTRACE1(GfaTfuStrError(errno));
 		return nRet;
     }
 
@@ -485,6 +598,7 @@ static int _ReviveBootloader(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla,
 	if(ctx == GfaBlmCtx_App)
 	{
 		TRACE1("Bootloader not executing!\n");
+		TTRACE1("Bootloader not executing");
 		return 0;
 	}
 
@@ -504,12 +618,14 @@ static int _ReviveBootloader(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla,
 		if((nRet = GfaMininetMasterTransmitFrame(hMst, frm, nLen)) != nLen)
 	    {
 			TRACE1("Error: %s!\n", GfaTfuStrError(errno));
+			TTRACE1(GfaTfuStrError(errno));
 			return -1;
 	    }
 
 	    if((nRet = GfaMininetMasterReceiveFrame(hMst, rx, sizeof(rx), true)) <= 0)
 	    {
 			TRACE1("Error: %s!\n", GfaTfuStrError(errno));
+			TTRACE1(GfaTfuStrError(errno));
 			return -1;
 	    }
 
@@ -518,6 +634,7 @@ static int _ReviveBootloader(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla,
 	    if(nRet == MINET_SLAVE_RESPONSE_INDEX_IS_STATUS_CODE)
 	    {
 			TRACE1("Error: %s!\n", GfaTfuStrError(-nStatus));
+			TTRACE1(GfaTfuStrError(-nStatus));
 			return -1;
 	    }
 	    else if(nRet == MINET_SLAVE_RESPONSE_SUCCESS)
@@ -567,6 +684,7 @@ static int _ModbusStartBootloader(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS p
 			else
 			{
 				TRACE1("Error: %s!\n", GfaTfuStrError(errno));
+				TTRACE1(GfaTfuStrError(errno));
 			}
 
 			GfaMbMstClose(hMbm);
@@ -575,6 +693,7 @@ static int _ModbusStartBootloader(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS p
 	}
 
 	TRACE1("Error: %s!\n", GfaTfuStrError(errno));
+	TTRACE1(GfaTfuStrError(errno));
 	return -1;
 }
 
@@ -587,6 +706,7 @@ static int _StartBootloader(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla, G
 	if(ctx == GfaBlmCtx_Boot)
 	{
 		TRACE2("Bootloader already executing!\n");
+		TTRACE2("Bootloader already executing");
 		return 0; // no error
 	}
 	else if(ctx == GfaBlmCtx_ModB)
@@ -595,10 +715,12 @@ static int _StartBootloader(HIMGFILE hIf, HGFABLM hBlm, LPCCMD_LINE_ARGS pcla, G
 	}
 
 	TRACE3("Starting bootloader.\n");
+	TTRACE3("Starting bootloader");
 
 	if((nRet = GfaBlmBootloaderExecute(hBlm, pcla->nNodeAddr, NULL, 1000)) != 0)
 	{
 		TRACE1("Error: %s!\n", GfaTfuStrError(errno));
+		TTRACE1(GfaTfuStrError(errno));
 		return nRet;
 	}
 
@@ -652,6 +774,7 @@ static bool _AutoBaud(HGFABLM hBlm, LPCMD_LINE_ARGS pcla)
             			pcla->nExBaudrate = pcla->nInitBaudrate;
             		bBaudrateHit = true;
             		TRACE3("Detected MiniNet connection @ %u,8,1,%c\n", scp.baud, scp.parity);
+            		TTRACE3("Detected MiniNet connection @ %u,8,1,%c", scp.baud, scp.parity);
             		break;
             	}
 				usleep(10000);
@@ -725,6 +848,7 @@ static bool _ModbusAutobaud(HGFABLM hBlm, LPCMD_LINE_ARGS pcla)
 						pcla->modbParity = nParities[i];
 	            		pcla->nModbBaudrate = nBaudrates[j];
 	            		TRACE3("Detected Modbus application @ %u,8,1,%c\n", pcla->nModbBaudrate, pcla->modbParity);
+	            		TTRACE3("Detected Modbus application @ %u,8,1,%c", pcla->nModbBaudrate, pcla->modbParity);
 	            		bBaudrateHit = true;
 						GfaMbMstWaitFrameDelay(hMbm);
 	            		break;
@@ -771,6 +895,7 @@ static void _OnUploadProgress(const char *pszFile, int nLine, LPGFA_BLM_DL_PROGR
 			UNUSED(pszFile);
 			UNUSED(nLine);
 			TRACE1("Error: %s!\n", GfaBlmStrError(pdlpp->nErrorCode));
+			TTRACE1(GfaBlmStrError(pdlpp->nErrorCode));
 #endif	//	_DEBUG
 			break;
 		case GBDPS_StartEraseFlash:
@@ -835,16 +960,35 @@ int main(int argc, char* argv[])
 	{
 		if(nRet > 0)
 		{
-			GfaTfuCmdOptDisplayHelp(cla.nQuestionMarks == 3);	// show Help and exit
-			return 0;
+			if(!cla.bPluginMode)
+			{
+				GfaTfuCmdOptDisplayHelp(cla.nQuestionMarks == 3);	// show Help and exit
+				return 0;
+			}
+			else
+			{
+				TTRACE1("Invalid command or option");
+				TTRACEEXIT("1");
+				return 1;
+			}
 		}
 		else if(nRet == (int)GFA_FU_ERROR_MISSING_COMMAND_OPT)	// A required option is missing
+		{
 			TRACE0("Error: %s: %s!\n", GfaTfuStrError(nRet), GfaTfuCmdOpt2String(cla.nMissingOptFlags));
+			TTRACE1("%s: %s", GfaTfuStrError(nRet), GfaTfuCmdOpt2String(cla.nMissingOptFlags));
+		}
 		else if(nRet == (int)GFA_FU_ERROR_MULTIPLE_COMMANDS)	// Multiple commands were given
+		{
 			TRACE0("Error: %s: %s!\n", GfaTfuStrError(nRet), GfaTfuCmdOpt2String(cla.nCmdFlags));
-		else
-			TRACE0("Error: %s!\n", GfaTfuStrError(nRet));		// Another error occured
+			TTRACE1("%s: %s", GfaTfuStrError(nRet), GfaTfuCmdOpt2String(cla.nCmdFlags));
+		}
+		else	// Another error occured
+		{
+			TRACE0("Error: %s!\n", GfaTfuStrError(nRet));
+			TTRACE1("%s", GfaTfuStrError(nRet));
+		}
 
+		TTRACEEXIT("%d", nRet);
 		return nRet;
 	}
 
@@ -882,18 +1026,27 @@ int main(int argc, char* argv[])
 
 		if(cla.bNeedImgFile)		// If the given command requires an image file, open it.
 		{							// This also performs some basic validations on the file.
+	    	GFA_IMG_INFO ii;
+
 			TRACE3("Opening image file %s.\n", cla.pszImgFile);
+			TTRACE3("Opening image file %s", cla.pszImgFile);
 
 		    if(!(hIf = GfaTfuImageFileOpen(cla.pszImgFile, cla.nStartAddr, true)))
 		    {
 				TRACE1("Error: %s!\n", GfaTfuStrError(errno)); // Something is wrong with the file
+				TTRACE1(GfaTfuStrError(errno));
 				break;
 		    }
 
+	    	GfaTfuImageFileGetInfo(hIf, &ii);
+
+			TTRACE(PLUGIN_TAG_IMG_LENGTH_FILE, "%u", ii.nImgLength);
+			TTRACE(PLUGIN_TAG_IMG_CRC32_FILE, "%u", ii.nImgCRC32);
+			TTRACE(PLUGIN_TAG_IMG_MATERIAL_FILE, "%s", ii.szImgMaterialNum);
+			TTRACE(PLUGIN_TAG_IMG_BUILD_FILE, "%s", ii.szImgNameBuild);
+
 		    if(cla.bShowFileImgInfo) // If only the file's image information was requested, dump it and exit.
 		    {
-		    	GFA_IMG_INFO ii;
-		    	GfaTfuImageFileGetInfo(hIf, &ii);
 			    GfaTfuDumpImageInfo(cla.pszImgFile, &ii);
 				break;
 			}
@@ -941,6 +1094,7 @@ int main(int argc, char* argv[])
 			// open a bootloader master instance
 
 			TRACE3("Opening bootloader master.\n");
+			TTRACE3("Opening bootloader master");
 
 			if((hBlm = GfaBlmOpen(&blmcp)))
 			{
@@ -952,6 +1106,7 @@ int main(int argc, char* argv[])
 
 				GfaBlmSetVerbosity(hBlm, cla.nVerbosity);	// Set the verbosity of the bootloader master and it's descendants
 				TRACE3("Connecting to target.\n");
+				TTRACE3("Connecting to target");
 
 				if(!_AutoBaud(hBlm, &cla)) // Try to detect the mininet baudrate and parity
 				{
@@ -961,6 +1116,7 @@ int main(int argc, char* argv[])
 		        		!(bModbusAppDetected = _ModbusAutobaud(hBlm, &cla)))
 		        	{
 						TRACE1("Error: %s!\n", GfaTfuStrError(errno));
+						TTRACE1(GfaTfuStrError(errno));
 						break;
 		        	}
 				}
@@ -983,13 +1139,15 @@ int main(int argc, char* argv[])
 					else if(!cla.bPing && !cla.bStartBoot)	// Ping works with a modbus application as well, so there's no need to start the bootloader.
 					{										// --start-boot is an explicit command on it's own and is handled later.
 						TRACE2("Nothing to do.\n");			// At this point either a --reset-boot or --revive-boot command was given. Both commands make no sense when any
-						break;								// kind of application is running, so just exit.
+						TTRACE2("Nothing to do");			// kind of application is running, so just exit.
+						break;
 					}
 		        }
 		        else
 				{
 		        	// No modbus application was detected, so we are dealing either with a mininet application or the bootloader itself. Find out what ...
 					TRACE3("Detecting running image.\n");
+					TTRACE3("Detecting running image");
 
 					ctx = GfaBlmGetExecutionContext(hBlm, cla.nNodeAddr);
 
@@ -1003,6 +1161,7 @@ int main(int argc, char* argv[])
 			        	if((nRet = _ReviveBootloader(hIf, hBlm, &cla, ctx, true)) != 0)
 			        	{
 							TRACE1("Error: %s!\n", GfaTfuStrError(errno));
+							TTRACE1(GfaTfuStrError(errno));
 							break;
 						}
 
@@ -1010,6 +1169,7 @@ int main(int argc, char* argv[])
 			        }
 
 			        TRACE3("Currently running: %s.\n", (ctx == GfaBlmCtx_App) ? "Application" : "Bootloader");
+			        TTRACE3("Currently running: %s", (ctx == GfaBlmCtx_App) ? "Application" : "Bootloader");
 			    }
 			    
 			    // handle the commands
@@ -1036,12 +1196,14 @@ int main(int argc, char* argv[])
 			else
 	        {	// GfaBlmOpen failed
 				TRACE1("Error: %s!\n", GfaTfuStrError(errno));
+				TTRACE1(GfaTfuStrError(errno));
 				break;
 	        }
 		}
 		else
         {	// GfaSerialGetDeviceInterface failed
 			TRACE1("Error: %s!\n", GfaTfuStrError(errno));
+			TTRACE1(GfaTfuStrError(errno));
 			break;
         }
 	}
@@ -1050,15 +1212,18 @@ int main(int argc, char* argv[])
 	if(hBlm)
 	{
 		TRACE3("Closing bootloader master.\n");
+		TTRACE3("Closing bootloader master");
 		GfaBlmClose(hBlm);
 	}
 
 	if(hIf)
 	{
 		TRACE3("Closing image file.\n");
+		TTRACE3("Closing image file");
 		GfaTfuImageFileClose(hIf);
 	}
 
+	TTRACEEXIT("%d", nRet);
 	return nRet;
 }
 

output.c

@@ -18,6 +18,7 @@
 /////////////////////////////////////////////////////////////////////////////
 
 extern int g_nVerbosity;
+extern bool g_bPluginMode;
 
 /////////////////////////////////////////////////////////////////////////////
 
@@ -49,6 +50,24 @@ int GfaTfuPrintF(int verb, const char *pszFormat, ...)
 	return 0;
 }
 
+int GfaTfuTaggedPrintF(int nTagNum, const char *pszFormat, ...)
+{
+	if(g_bPluginMode)
+	{
+		int nRet;
+		FILE *pf = stdout;
+		char szFormat[256];
+		va_list args;
+		va_start(args, pszFormat);
+		sprintf(szFormat, "<%d>%s</%d>\n", nTagNum, pszFormat, nTagNum);
+		nRet = vfprintf(pf, szFormat, args);
+		fflush(pf);
+		va_end(args);
+		return nRet;
+	}
+	return 0;
+}
+
 /////////////////////////////////////////////////////////////////////////////
 
 void GfaTfuDumpImageInfo(const char *pszContext, LPCGFA_IMG_INFO pii)

output.h

@@ -7,6 +7,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <gfabootlmast.h>
+#include "qmlplugin/libgfativaflashplugin/tagnames.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -24,9 +25,18 @@ extern "C" {
 #define TRACE3(...)								GfaTfuPrintF(3, __VA_ARGS__)
 #define TRACE4(...)								GfaTfuPrintF(4, __VA_ARGS__)
 
+#define TTRACE(t, ...)							GfaTfuTaggedPrintF(t, __VA_ARGS__)
+
+#define TTRACE1(...)							GfaTfuTaggedPrintF(PLUGIN_TAG_ERROR, __VA_ARGS__)
+#define TTRACE2(...)							GfaTfuTaggedPrintF(PLUGIN_TAG_INFO, __VA_ARGS__)
+#define TTRACE3(...)							GfaTfuTaggedPrintF(PLUGIN_TAG_STATUS, __VA_ARGS__)
+
+#define TTRACEEXIT(...)							GfaTfuTaggedPrintF(PLUGIN_TAG_EXIT_CODE, __VA_ARGS__)
+
 /////////////////////////////////////////////////////////////////////////////
 
 int			GfaTfuPrintF(int verb, const char *pszFormat, ...);
+int			GfaTfuTaggedPrintF(int nTagNum, const char *pszFormat, ...);
 void		GfaTfuDumpImageInfo(const char *pszContext, LPCGFA_IMG_INFO pii);
 
 int			GfaTfuGetPercentString(uint32_t nCur, uint32_t nMax, char *pszString, size_t nCChString);

qmlplugin/Demo/main.qml

@@ -23,15 +23,15 @@ Window {
         id: idTivaFlash
         tivaFlashUtilPath: "/opt/GfA/tivaflashutil/gfativaflashutil"
         itfName: "/dev/ttyO4"
-        statNum: 1
-        mbSlaveId: 100
+        slvIdIsNodeAddr: false
+        imgFile: "/opt/GfA/tivaflashutil/OLS-1V1_0009_crc.bin"
         verbosity: 3
 
         onExecOut:
         {
-            idExecOut.text += out;
+            idExecOut.text += msg + "\n";
             idExecOut.update();
-            console.log(out);
+            console.log(msg);
         }
 	}
 
@@ -39,8 +39,15 @@ Window {
         anchors.fill: parent
         onClicked:
         {
+        	var statNr = 1;
+        	var mbAddr = 100;
+            var ret = false;
             idExecOut.text = "";
-        	idTivaFlash.showMatSer();
+//            ret = idTivaFlash.pingTarget(statNr, mbAddr);
+//            ret = idTivaFlash.startBootloader(statNr, mbAddr);
+//            ret = idTivaFlash.resetBootloader(statNr, mbAddr);
+            ret = idTivaFlash.validateImgFile(statNr, mbAddr);
+            ret = false;
         }
     }
 }

qmlplugin/libgfativaflashplugin/gfativaflash.cpp

@@ -1,172 +1,598 @@
-#include <stdio.h>
-#include <stdarg.h>
-#include <string>
-#include "gfativaflash.h"
-
-/////////////////////////////////////////////////////////////////////////////
-
-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;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-
-TivaFlash::TivaFlash(QObject *pParent) : QObject(pParent), m_statNum(0), m_nodeAddr(0), m_mbSlaveId(0), m_verbosity(-1)
-{
-	setObjectName("TivaFlash");
-}
-
-TivaFlash::~TivaFlash(void)
-{
-}
-
-/////////////////////////////////////////////////////////////////////////////
-
-int TivaFlash::execFlashUtil(const char *pszOpt)
-{
-	FILE* pd;
-	char buffer[256];
-	std::string strCmd;
-
-	strCmd = _formatString("\"%s\" %s 2>&1", m_tivaFlashUtilPath.c_str(), pszOpt);
-
-	if(m_verbosity >= 0)
-		strCmd += _formatString(" -v%d", m_verbosity);
-		
-	if((pd = popen(strCmd.c_str(), "r")))
-	{
-		while(fgets(buffer, sizeof buffer, pd))
-		{
-			onCmdOutput(buffer);
-		}
-
-		pclose(pd);
-	}
-
-	return 0;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-
-std::string TivaFlash::statNumOrNodeAddr(void) const
-{
-	std::string ret;
-
-	if(m_nodeAddr)
-		ret = _formatString("--node-addr=%d", m_nodeAddr);
-	else if(m_statNum)
-		ret = _formatString("--stat-num=%d", m_statNum);
-	
-	return ret;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-
-void TivaFlash::onCmdOutput(const char *pszOut) const
-{
-	emit execOut(QString(pszOut));
-}
-
-/////////////////////////////////////////////////////////////////////////////
-
-int TivaFlash::showHelp(void)
-{
-	const char *pszOpt = "--help";
-	return execFlashUtil(pszOpt);
-}
-
-/////////////////////////////////////////////////////////////////////////////
-
-int TivaFlash::showMatSer(void)
-{
-	std::string strOpt;
-	strOpt = _formatString("--show-mat-ser --itf-name=\"%s\" %s", m_itfName.c_str(), statNumOrNodeAddr().c_str());
-	if(m_mbSlaveId)
-		strOpt += _formatString(" --mb-slave-id=%d", m_mbSlaveId);
-	return execFlashUtil(strOpt.c_str());
-}
-
-/////////////////////////////////////////////////////////////////////////////
-
-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();
-}
-
-/////////////////////////////////////////////////////////////////////////////
-
-int TivaFlash::statNum(void) const
-{
-	return m_statNum;
-}
-
-void TivaFlash::setStatNum(int val)
-{
-	m_statNum = val;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-
-int TivaFlash::nodeAddr(void) const
-{
-	return m_nodeAddr;
-}
-
-void TivaFlash::setNodeAddr(int val)
-{
-	m_nodeAddr = val;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-
-int TivaFlash::mbSlaveId(void) const
-{
-	return m_mbSlaveId;
-}
-
-void TivaFlash::setMbSlaveId(int val)
-{
-	m_mbSlaveId = val;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-
-int TivaFlash::verbosity(void) const
-{
-	return m_verbosity;
-}
-
-void TivaFlash::setVerbosity(int val)
-{
-	m_verbosity = val;
-}
+#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)))
+
+/////////////////////////////////////////////////////////////////////////////
+
+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;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+
+TivaFlash::TivaFlash(QObject *pParent) :	QObject(pParent),
+											m_nExitCode(0),
+											m_slvIdIsNodeAddr(false),
+											m_verbosity(-1),
+											m_imgSizeFile(0),
+											m_imgCRC32File(0.0)
+{
+	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("");
+	}
+}
+
+TivaFlash::~TivaFlash(void)
+{
+}
+
+/////////////////////////////////////////////////////////////////////////////
+
+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;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+
+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;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+
+void TivaFlash::onCmdOutput(int nSlvID, const char *pszOut)
+{
+	std::string s;
+	int nTag = parseTaggedString(pszOut, s);
+	
+	if(nTag >= 0)
+	{
+		QString qs = QString::fromStdString(s);
+
+		switch(nTag)
+		{
+		/////////////////////////////////////////////////////////////////////
+
+		case PLUGIN_TAG_EXIT_CODE:
+			m_nExitCode = qs.toInt();
+//			emit execOut(nSlvID, nTag, qs);
+			break;
+
+		/////////////////////////////////////////////////////////////////////
+
+		case PLUGIN_TAG_STATUS:
+			if(_TEST_VERBOSITY(m_verbosity, PLUGIN_TAG_STATUS))
+				emit execOut(nSlvID, nTag, qs);
+			break;
+		case PLUGIN_TAG_INFO:
+			if(_TEST_VERBOSITY(m_verbosity, PLUGIN_TAG_INFO))
+				emit execOut(nSlvID, nTag, qs);
+			break;
+		case PLUGIN_TAG_ERROR:
+			if(_TEST_VERBOSITY(m_verbosity, PLUGIN_TAG_ERROR))
+				emit execOut(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;
+		}
+	}
+}
+
+/////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////
+
+bool TivaFlash::getMatSer(int nSlvID, int nMbID)
+{
+	if(!_IS_VALID_SLV_ID(nSlvID))
+		return -1;
+
+	setMaterialEeprom(nSlvID, "");
+	setSerialEeprom(nSlvID, "");
+
+	std::string strOpt = _formatString("--show-mat-ser --itf-name=\"%s\" %s", m_itfName.c_str(), getSlavIDs(nSlvID, nMbID).c_str());
+	return execFlashUtil(nSlvID, strOpt.c_str());
+}
+
+bool TivaFlash::getTargetImgInfo(int nSlvID, int nMbID)
+{
+	if(!_IS_VALID_SLV_ID(nSlvID))
+		return -1;
+
+	setImgSizeBoot(nSlvID, 0);
+	setImgCRC32Boot(nSlvID, 0.0);
+	setImgMaterialBoot(nSlvID, "");
+	setImgBuildBoot(nSlvID, "");
+
+	setImgSizeApp(nSlvID, 0);
+	setImgCRC32App(nSlvID, 0.0);
+	setImgMaterialApp(nSlvID, "");
+	setImgBuildApp(nSlvID, "");
+
+	std::string strOpt = _formatString("--show-dev-img-info --itf-name=\"%s\" %s", m_itfName.c_str(), getSlavIDs(nSlvID, nMbID).c_str());
+	return execFlashUtil(nSlvID, strOpt.c_str());
+}
+
+bool TivaFlash::pingTarget(int nSlvID, int nMbID)
+{
+	if(!_IS_VALID_SLV_ID(nSlvID))
+		return -1;
+
+	std::string strOpt = _formatString("--ping-target --itf-name=\"%s\" %s", m_itfName.c_str(), getSlavIDs(nSlvID, nMbID).c_str());
+	return execFlashUtil(nSlvID, strOpt.c_str());
+}
+
+bool TivaFlash::startBootloader(int nSlvID, int nMbID)
+{
+	if(!_IS_VALID_SLV_ID(nSlvID))
+		return -1;
+
+	std::string strOpt = _formatString("--start-boot --itf-name=\"%s\" %s", m_itfName.c_str(), getSlavIDs(nSlvID, nMbID).c_str());
+	return execFlashUtil(nSlvID, strOpt.c_str());
+}
+
+bool TivaFlash::resetBootloader(int nSlvID, int nMbID)
+{
+	if(!_IS_VALID_SLV_ID(nSlvID))
+		return -1;
+
+	std::string strOpt = _formatString("--reset-boot --itf-name=\"%s\" %s", m_itfName.c_str(), getSlavIDs(nSlvID, nMbID).c_str());
+	return execFlashUtil(nSlvID, strOpt.c_str());
+}
+
+bool TivaFlash::validateImgFile(int nSlvID, int nMbID)
+{
+	if(!_IS_VALID_SLV_ID(nSlvID))
+		return -1;
+
+	std::string strOpt = _formatString("--validate-img --itf-name=\"%s\" %s \"%s\"", m_itfName.c_str(), getSlavIDs(nSlvID, nMbID).c_str(), m_imgFile.c_str());
+	return execFlashUtil(nSlvID, strOpt.c_str());
+}
+
+/////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////
+
+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;
+		emit verbosityChanged(m_verbosity);
+	}
+}
+
+/////////////////////////////////////////////////////////////////////////////
+
+QString TivaFlash::imgFile(void) const
+{
+	return QString::fromStdString(m_imgFile);
+}
+
+void TivaFlash::setImgFile(const QString &val)
+{
+	m_imgFile = val.toStdString();
+}
+
+/////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////
+
+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);
+	}
+}

qmlplugin/libgfativaflashplugin/gfativaflash.h

@@ -7,15 +7,21 @@
 #include <string>
 #include <QObject>
 #include <QList>
-#include <QQmlListProperty>
-#include <qqmlparserstatus.h>
+#include <QStringList>
+//#include <QQmlListProperty>
+//#include <qqmlparserstatus.h>
+#include "tagnames.h"
 
 #ifdef __cplusplus
 
 /////////////////////////////////////////////////////////////////////////////
 // gfativaflash.h - Declarations:
 
-typedef void (*PFN_READ_OUTPUT_CALLBACK)(const char *pszOut);
+#define _MAX_SLAVE_COUNT								256
+#define _MB_BROADCAST_ADDRESS							0
+#define _MB_MAX_SLAVE_ID								247
+#define _IS_VALID_SLV_ID(id)							(((id) >= 0) && ((id) < _MAX_SLAVE_COUNT))
+#define _IS_VALID_MB_ID(id)								(((id) != _MB_BROADCAST_ADDRESS) && ((id) <= _MB_MAX_SLAVE_ID))
 
 /////////////////////////////////////////////////////////////////////////////
 
@@ -24,53 +30,138 @@ class TivaFlash : public QObject
     Q_OBJECT
     Q_PROPERTY(QString tivaFlashUtilPath READ tivaFlashUtilPath WRITE setTivaFlashUtilPath)
     Q_PROPERTY(QString itfName READ itfName WRITE setItfName)
-    Q_PROPERTY(int statNum READ statNum WRITE setStatNum)
-    Q_PROPERTY(int nodeAddr READ nodeAddr WRITE setNodeAddr)
-    Q_PROPERTY(int mbSlaveId READ mbSlaveId WRITE setMbSlaveId)
-    Q_PROPERTY(int verbosity READ verbosity WRITE setVerbosity)
+	Q_PROPERTY(bool slvIdIsNodeAddr READ slvIdIsNodeAddr WRITE setSlvIdIsNodeAddr)
+	Q_PROPERTY(int verbosity READ verbosity WRITE setVerbosity NOTIFY verbosityChanged)
+    Q_PROPERTY(QString imgFile READ imgFile WRITE setImgFile)
+
+    Q_PROPERTY(QStringList materialEeprom READ materialEeprom NOTIFY materialEepromChanged)
+    Q_PROPERTY(QStringList serialEeprom READ serialEeprom NOTIFY serialEepromChanged)
+
+	Q_PROPERTY(QStringList imgMaterialBoot READ imgMaterialBoot NOTIFY imgMaterialBootChanged)
+	Q_PROPERTY(QStringList imgBuildBoot READ imgBuildBoot NOTIFY imgBuildBootChanged)
+    Q_PROPERTY(QList<int> imgSizeBoot READ imgSizeBoot NOTIFY imgSizeBootChanged)
+	Q_PROPERTY(QList<double> imgCRC32Boot READ imgCRC32Boot NOTIFY imgCRC32BootChanged)
+
+	Q_PROPERTY(QStringList imgMaterialApp READ imgMaterialApp NOTIFY imgMaterialAppChanged)
+	Q_PROPERTY(QStringList imgBuildApp READ imgBuildApp NOTIFY imgBuildAppChanged)
+    Q_PROPERTY(QList<int> imgSizeApp READ imgSizeApp NOTIFY imgSizeAppChanged)
+	Q_PROPERTY(QList<double> imgCRC32App READ imgCRC32App NOTIFY imgCRC32AppChanged)
+
+    Q_PROPERTY(QString imgMaterialFile READ imgMaterialFile NOTIFY materialFileChanged)
+	Q_PROPERTY(QString imgBuildFile READ imgBuildFile NOTIFY imgBuildFileChanged)
+	Q_PROPERTY(int imgSizeFile READ imgSizeFile NOTIFY imgSizeFileChanged)
+	Q_PROPERTY(double imgCRC32File READ imgCRC32File NOTIFY imgCRC32FileChanged)
 
 public:
     explicit TivaFlash(QObject *pParent = NULL);
     virtual ~TivaFlash(void);
 
 public:
-	Q_INVOKABLE int showHelp(void);
-	Q_INVOKABLE int showMatSer(void);
+	Q_INVOKABLE bool getMatSer(int nSlvID, int nMbID = 0);
+	Q_INVOKABLE bool getTargetImgInfo(int nSlvID, int nMbID = 0);
+	Q_INVOKABLE bool pingTarget(int nSlvID, int nMbID = 0);
+	Q_INVOKABLE bool startBootloader(int nSlvID, int nMbID = 0);
+	Q_INVOKABLE bool resetBootloader(int nSlvID, int nMbID = 0);
+	Q_INVOKABLE bool validateImgFile(int nSlvID, int nMbID = 0);
 
 signals:
-	void execOut(QString out) const;
+	void execOut(int slv, int ctx, QString msg) const;
 
-private:
-	QString tivaFlashUtilPath(void) const;
-	void setTivaFlashUtilPath(const QString &val);
+	void verbosityChanged(int val) const;
 
-	QString itfName(void) const;
-	void setItfName(const QString &val);
+	void materialEepromChanged(void) const;
+	void serialEepromChanged(void) const;
 
-	int statNum(void) const;
-	void setStatNum(int val);
+	void imgSizeBootChanged(void) const;
+	void imgCRC32BootChanged(void) const;
+	void imgMaterialBootChanged(void) const;
+	void imgBuildBootChanged(void) const;
 
-	int nodeAddr(void) const;
-	void setNodeAddr(int val);
+	void imgSizeAppChanged(void) const;
+	void imgCRC32AppChanged(void) const;
+	void imgMaterialAppChanged(void) const;
+	void imgBuildAppChanged(void) const;
 
-	int mbSlaveId(void) const;
-	void setMbSlaveId(int val);
+	void materialFileChanged(const QString &val) const;
+	void imgBuildFileChanged(const QString &val) const;
+	void imgSizeFileChanged(int val) const;
+	void imgCRC32FileChanged(double val) const;
 
+private:
+	QString tivaFlashUtilPath(void) const;
+	void setTivaFlashUtilPath(const QString &val);
+	QString itfName(void) const;
+	void setItfName(const QString &val);
+	bool slvIdIsNodeAddr(void) const;
+	void setSlvIdIsNodeAddr(bool val);
 	int verbosity(void) const;
 	void setVerbosity(int val);
-
+	QString imgFile(void) const;
+	void setImgFile(const QString &val);
+
+	const QStringList& materialEeprom(void) const;
+	void setMaterialEeprom(int nSlvID, const QString &val);
+	const QStringList& serialEeprom(void) const;
+	void setSerialEeprom(int nSlvID, const QString &val);
+
+	const QList<int>& imgSizeBoot(void) const;
+	void setImgSizeBoot(int nSlvID, int val);
+	const QList<double>& imgCRC32Boot(void) const;
+	void setImgCRC32Boot(int nSlvID, double val);
+	const QStringList& imgMaterialBoot(void) const;
+	void setImgMaterialBoot(int nSlvID, const QString &val);
+	const QStringList& imgBuildBoot(void) const;
+	void setImgBuildBoot(int nSlvID, const QString &val);
+
+	const QList<int>& imgSizeApp(void) const;
+	void setImgSizeApp(int nSlvID, int val);
+	const QList<double>& imgCRC32App(void) const;
+	void setImgCRC32App(int nSlvID, double val);
+	const QStringList& imgMaterialApp(void) const;
+	void setImgMaterialApp(int nSlvID, const QString &val);
+	const QStringList& imgBuildApp(void) const;
+	void setImgBuildApp(int nSlvID, const QString &val);
+
+	int imgSizeFile(void) const;
+	void setImgSizeFile(int val);
+	double imgCRC32File(void) const;
+	void setImgCRC32File(double val);
+	const QString& imgMaterialFile(void) const;
+	void setImgMaterialFile(const QString &val);
+	const QString& imgBuildFile(void) const;
+	void setImgBuildFile(const QString &val);
+	
 private:
-	int execFlashUtil(const char *pszOpt);
-	void onCmdOutput(const char *pszOut) const;
-	std::string statNumOrNodeAddr(void) const;
+	bool execFlashUtil(int nSlvID, const char *pszOpt);
+	void onCmdOutput(int nSlvID, const char *pszOut);
+	std::string getSlavIDs(int nSlvID, int nMbID) const;
+	int parseTaggedString(const char *pszIn, std::string &sOut) const;
 
 private:
-	std::string m_itfName;
+	int m_nExitCode;
 	std::string m_tivaFlashUtilPath;
-	int m_statNum;
-	int m_nodeAddr;
-	int m_mbSlaveId;
+	std::string m_itfName;
+	bool m_slvIdIsNodeAddr;
 	int m_verbosity;
+	std::string m_imgFile;
+
+	QStringList m_materialEeprom;
+	QStringList m_serialEeprom;
+
+	QList<int> m_imgSizeBoot;
+	QList<double> m_imgCRC32Boot;
+	QStringList m_imgMaterialBoot;
+	QStringList m_imgBuildBoot;
+
+	QList<int> m_imgSizeApp;
+	QList<double> m_imgCRC32App;
+	QStringList m_imgMaterialApp;
+	QStringList m_imgBuildApp;
+
+	int m_imgSizeFile;
+	double m_imgCRC32File;
+	QString m_imgMaterialFile;
+	QString m_imgBuildFile;
 };
 
 /////////////////////////////////////////////////////////////////////////////

qmlplugin/libgfativaflashplugin/tagnames.h

@@ -0,0 +1,45 @@
+// tagnames.h :
+//
+
+#if !defined(AGD_TAGNAMES_H__0DFDE1D3_67CC_4E5A_8148_E26AD8E5FA1F__INCLUDED_)
+#define AGD_TAGNAMES_H__0DFDE1D3_67CC_4E5A_8148_E26AD8E5FA1F__INCLUDED_
+
+#ifdef __cplusplus
+extern "C" {
+#endif	//	__cplusplus
+
+/////////////////////////////////////////////////////////////////////////////
+// tagnames.h - Declarations:
+
+typedef enum _PLUGIN_TAG_NUMBERS
+{
+	PLUGIN_TAG_EXIT_CODE,
+
+	PLUGIN_TAG_ERROR,
+	PLUGIN_TAG_INFO,
+	PLUGIN_TAG_STATUS,
+
+	PLUGIN_TAG_IMG_MATERIAL_EEPROM,
+	PLUGIN_TAG_IMG_SERIAL_EEPROM,
+
+	PLUGIN_TAG_IMG_LENGTH_BOOT,
+	PLUGIN_TAG_IMG_CRC32_BOOT,
+	PLUGIN_TAG_IMG_MATERIAL_BOOT,
+	PLUGIN_TAG_IMG_BUILD_BOOT,
+
+	PLUGIN_TAG_IMG_LENGTH_APP,
+	PLUGIN_TAG_IMG_CRC32_APP,
+	PLUGIN_TAG_IMG_MATERIAL_APP,
+	PLUGIN_TAG_IMG_BUILD_APP,
+
+	PLUGIN_TAG_IMG_LENGTH_FILE,
+	PLUGIN_TAG_IMG_CRC32_FILE,
+	PLUGIN_TAG_IMG_MATERIAL_FILE,
+	PLUGIN_TAG_IMG_BUILD_FILE
+}PLUGIN_TAG_NUMBERS;
+
+/////////////////////////////////////////////////////////////////////////////
+#ifdef __cplusplus
+}
+#endif	//	__cplusplus
+#endif	//	!defined(AGD_TAGNAMES_H__0DFDE1D3_67CC_4E5A_8148_E26AD8E5FA1F__INCLUDED_)