Bridge Unicast Fix

Core/Inc/NbusBridge.h

@@ -24,6 +24,8 @@
 /** Makro zistí kód funkcie z RX paketu */
 #define FUNCTION_CODE(packet)   packet[2]
 
+#define DATA0_ADDRESS(packet)   packet[3]
+
 /** Adresa broadcastu */
 #define BROADCAST_ADDRESS	0
 /** Virtuálna adresa modulu nBus Bridge */
@@ -33,8 +35,10 @@
 #define BRIDGE_INFO_HW_FAMILY	"STM"
 #define BRIDGE_INFO_HW_VERSION	"0.5"
 
+#define PDU_SIZE 3
 #define RX_META	4
 
+
 #define DATAPACKET_SIZE  (NBUS_MAX_FRAME_SIZE*MAX_SLAVES)
 
 /* DEFINES END */
@@ -63,14 +67,13 @@ private:
 	/** Príznak indikuje, či je modul Bridge v stave RUN */
 	RunState_e _run_state;
     /** Interný buffer */
-	DataFrame *_workerFrame;
+	DataFrame *_worker_frame_ptr;
 	/** Pole bajtov použité pre generovanie odpovede pomocou triedy DataFrame */
-	uint8_t _dataPacket[DATAPACKET_SIZE];
+	uint8_t _data_packet[DATAPACKET_SIZE];
 	/** Dataframe (wrapper nad _dataPacket), do ktorého za vygeneruje odsielaný packet.*/
-	DataFrame *_dataFrame;
+	DataFrame _raw_data_frame;
+	DataFrame _master_frame;
 
-	void transmit(DataFrame *packet);
-	DataFrame *_frame_nbus_internal;
 	Nbus_pdu _pdu;
 
 public:
@@ -82,8 +85,11 @@ public:
 	void scan();
 	uint8_t getNumSlaves();
 	NbusSlave * getSlave(uint8_t index);
-	DataFrame * getSlavesInfo(uint8_t *rxFrame);
-	void sendResponseToMaster(DataFrame *response_frame);
+
+
+	DataFrame * getBridgeSlaves();
+	DataFrame * getBridgeInfo();
+
 	void processRequest(uint8_t *rxFrame, uint8_t size);
 	void process_bridge_request(uint8_t *rxFrame, uint8_t size);
 	void process_slave_request(uint8_t *rxFrame, uint8_t size);

Core/Inc/NbusCommunicator.h

@@ -29,21 +29,19 @@ private:
 	uint8_t _data_packet_tx[NBUS_MAX_FRAME_SIZE];
 	uint8_t _data_packet_comm[NBUS_MAX_FRAME_SIZE];
 	uint8_t _data_packet_rx[NBUS_MAX_FRAME_SIZE];
-	DataFrame *_packet_tx;
-	DataFrame *_packet_rx;
+	DataFrame _packet_tx;
+	DataFrame _packet_rx;
 	UART_HandleTypeDef *_uart_nbus;
 	UART_HandleTypeDef *_uart_master;
 	void _receive();
 public:
 	NbusCommunicator(UART_HandleTypeDef*, UART_HandleTypeDef*);
 	void sendToMaster(DataFrame *master_frame);
+
 	virtual ~NbusCommunicator();
 
 	DataFrame* sendAndReceive(Nbus_pdu *pdu, uint8_t *data, uint8_t data_len);
-	DataFrame* formatSlaveInfo(uint8_t rx_frame[], uint8_t slave_address[], uint8_t num);
 	void send(Nbus_pdu *pdu, uint8_t *data, uint8_t data_len);
-
-	DataFrame *formatPacket(uint8_t *rxFrame, uint8_t size);
 };
 
 

Core/Src/NbusBridge.cpp

@@ -38,6 +38,8 @@ static uint8_t crc8x_fast(void const *mem, uint16_t len)
 }
 
 NbusBridge::NbusBridge()
+: _raw_data_frame(_data_packet, DATAPACKET_SIZE, TYPE_RAW, CRC_OFF),
+  _master_frame(_data_packet, DATAPACKET_SIZE, TYPE_PLAIN, CRC_ON)
 {
 
     _communicator = NULL;
@@ -60,7 +62,6 @@ void NbusBridge::setCommunicator(NbusCommunicator *nc)
     _num_slaves = 0;
     _run_state = STATE_STOPPED;
     _pdu.sa = BROADCAST_ADDRESS;
-    _dataFrame = new DataFrame(_dataPacket, sizeof(_dataPacket), TYPE_RAW, CRC_OFF);
 }
 
 NbusBridge::~NbusBridge()
@@ -140,17 +141,6 @@ uint8_t NbusBridge::getNumSlaves()
     return _num_slaves;
 }
 
-/**
- * Odošle odpoveď uzlu Master (PC)
- */
-void NbusBridge::sendResponseToMaster(DataFrame *response_frame)
-{
-    if (response_frame != NULL && response_frame->IsEmpty() == false)
-    {
-        _communicator->sendToMaster(response_frame);
-    }
-}
-
 /**
  * Na internú zbernicu odošle Broadcast request "START"
  */
@@ -210,41 +200,42 @@ void NbusBridge::process_broadcast(uint8_t *rxFrame)
  */
 void NbusBridge::process_bridge_request(uint8_t *rxFrame, uint8_t size)
 {
-    switch (FUNCTION_CODE(rxFrame))
-    {
+	_master_frame.Init();
+	_master_frame.AddArray(rxFrame, PDU_SIZE);
 
+	switch (FUNCTION_CODE(rxFrame))
+    {
     case FC_ECHO: /* 1 */
-        _frame_nbus_internal = _communicator->formatPacket(rxFrame, size);
+    	_master_frame.AddArray(&DATA0_ADDRESS(rxFrame), size  - RX_META);
         break;
 
     case FC_RESET: /* 9 */
     {
         scan_request = 1;
         // send same frame back
-        _frame_nbus_internal = _communicator->formatPacket(rxFrame, size);
+    	_master_frame.AddArray(&DATA0_ADDRESS(rxFrame), size  - RX_META);
     }
     break;
 
     case FC_INFO: /* 0xE => 15 */
-        /*
-         * verzia
-         * HW
-         * HW.verzia
-         */
-        _frame_nbus_internal->Init();
-        _frame_nbus_internal->AddArray(rxFrame, 3); // addheader
-        _frame_nbus_internal->AddArray((uint8_t *)BRIDGE_INFO_VERSION, 3);
-        _frame_nbus_internal->AddArray((uint8_t *)BRIDGE_INFO_HW_FAMILY, 3);
-        _frame_nbus_internal->AddArray((uint8_t *)BRIDGE_INFO_HW_VERSION, 3);
-        _frame_nbus_internal->Commit();
+    	_master_frame.AddArray((uint8_t *)BRIDGE_INFO_VERSION, 3);
+    	_master_frame.AddArray((uint8_t *)BRIDGE_INFO_HW_FAMILY, 3);
+    	_master_frame.AddArray((uint8_t *)BRIDGE_INFO_HW_VERSION, 3);
         break;
 
     case FC_SLAVES: /* 0x10 => 16 */
-        _frame_nbus_internal = getSlavesInfo(rxFrame);
+    	for (uint8_t i = 0; i < _num_slaves; i++)
+    	{
+    		_master_frame.AddInt8(i + 1);
+    		_master_frame.AddInt8(_slave_adress[i]);
+    	}
         break;
 
     default:; // nothing
     }
+
+    _master_frame.Commit();
+	_communicator->sendToMaster(&_master_frame);
 }
 
 void NbusBridge::process_slave_request(uint8_t *rxFrame, uint8_t size)
@@ -266,26 +257,26 @@ void NbusBridge::process_slave_request(uint8_t *rxFrame, uint8_t size)
     {
 
     case FC_FIND: /* 0 */
-        _frame_nbus_internal = selected_slave->nbus_module_find();
+        _worker_frame_ptr = selected_slave->nbus_module_find();
         break;
 
     case FC_ECHO: /* 1 */
-        _frame_nbus_internal = selected_slave->nbus_echo(&rxFrame[3], size - 4);
+    	_worker_frame_ptr = selected_slave->nbus_echo(&DATA0_ADDRESS(rxFrame), size - RX_META);
         break;
 
     case FC_PARAM: /* 4 */
         if (size == RX_META)
         {
-            _frame_nbus_internal = selected_slave->nbus_sensor_parameters(SENSOR_ADDRESS(rxFrame));
+        	_worker_frame_ptr = selected_slave->nbus_sensor_parameters(SENSOR_ADDRESS(rxFrame));
         }
         else
         {
-            _frame_nbus_internal = selected_slave->nbus_sensor_parameter(SENSOR_ADDRESS(rxFrame), rxFrame[RX_META - 1]);
+        	_worker_frame_ptr = selected_slave->nbus_sensor_parameter(SENSOR_ADDRESS(rxFrame), rxFrame[RX_META - 1]);
         }
         break;
 
     case FC_SENSOR_CNT: /* 5 */
-        _frame_nbus_internal = selected_slave->nbus_sensor_count();
+    	_worker_frame_ptr = selected_slave->nbus_sensor_count();
         break;
 
     case FC_SLEEP: /* 6 */
@@ -304,22 +295,22 @@ void NbusBridge::process_slave_request(uint8_t *rxFrame, uint8_t size)
         break;
 
     case FC_DATA: /* 0xB => 11  Get data from specific slave, Unicast mode */
-        _frame_nbus_internal = selected_slave->nbus_sensor_getData(SENSOR_ADDRESS(rxFrame));
+    	_worker_frame_ptr = selected_slave->nbus_sensor_getData(SENSOR_ADDRESS(rxFrame));
         break;
 
     case FC_SYNC: /* 0xC => 12 */
         break;
 
     case FC_SENSOR_TYPE: /* 0xD => 13 */
-        _frame_nbus_internal = selected_slave->nbus_sensor_type(SENSOR_ADDRESS(rxFrame));
+    	_worker_frame_ptr = selected_slave->nbus_sensor_type(SENSOR_ADDRESS(rxFrame));
         break;
 
     case FC_INFO: /* 0xE => 14 */
-        _frame_nbus_internal = selected_slave->nbus_module_info();
+    	_worker_frame_ptr = selected_slave->nbus_module_info();
         break;
 
     case FC_SENSOR_FORMAT: /* 0xF => 15 */
-        _frame_nbus_internal = selected_slave->nbus_sensor_format(SENSOR_ADDRESS(rxFrame));
+    	_worker_frame_ptr = selected_slave->nbus_sensor_format(SENSOR_ADDRESS(rxFrame));
         break;
 
     default:
@@ -328,18 +319,41 @@ void NbusBridge::process_slave_request(uint8_t *rxFrame, uint8_t size)
 
     if (send_reponse == 1)
     {
-        sendResponseToMaster(_frame_nbus_internal);
+        _communicator->sendToMaster(_worker_frame_ptr);
     }
 }
 
 /**
  * Pripraví informáciu o všetkcýh nBus slave moduloch
  */
-DataFrame *NbusBridge::getSlavesInfo(uint8_t *rx_frame)
+DataFrame* NbusBridge::getBridgeSlaves()
 {
-    return _communicator->formatSlaveInfo(rx_frame, _slave_adress, _num_slaves);
+	_raw_data_frame.Init();
+
+	for (uint8_t i = 0; i < _num_slaves; i++)
+	{
+		_raw_data_frame.AddInt8(i + 1);
+		_raw_data_frame.AddInt8(_slave_adress[i]);
+	}
+
+	_raw_data_frame.Commit();
+
+	return &_raw_data_frame;
+}
+
+DataFrame * NbusBridge::getBridgeInfo()
+{
+	_raw_data_frame.Init();
+	_raw_data_frame.AddArray((uint8_t *)BRIDGE_INFO_VERSION, 3);
+	_raw_data_frame.AddArray((uint8_t *)BRIDGE_INFO_HW_FAMILY, 3);
+	_raw_data_frame.AddArray((uint8_t *)BRIDGE_INFO_HW_VERSION, 3);
+	_raw_data_frame.Commit();
+
+	return &_raw_data_frame;
 }
 
+
+
 /**
  * Implementácia rozhrania nBus.
  */
@@ -352,12 +366,15 @@ void NbusBridge::processRequest(uint8_t *rxFrame, uint8_t size)
         return;
     }
 
-    if (MODULE_ADDRESS(rxFrame) == BROADCAST_ADDRESS)
+    _pdu.ma = rxFrame[0];
+    _pdu.sa = rxFrame[1];
+    _pdu.fc = (Nbus_FC_e)rxFrame[2];
+
+    if (_pdu.ma == BROADCAST_ADDRESS)
     {
-        if (SENSOR_ADDRESS(rxFrame) == BRIDGE_ADDRESS)
+        if (_pdu.sa == BRIDGE_ADDRESS)
         {
             process_bridge_request(rxFrame, size);
-            sendResponseToMaster(_frame_nbus_internal);
         }
         else
         {
@@ -399,9 +416,9 @@ void NbusBridge::processRunningState()
     HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_SET);
     NbusSlave *slave = NULL;
     uint8_t *slaveFrameResponse;
-    _dataFrame->Init();
-    _dataFrame->AddHeader(TYPE_HEADER_2B);
-    _dataFrame->AddInt32(HAL_GetTick());
+    _raw_data_frame.Init();
+    _raw_data_frame.AddHeader(TYPE_HEADER_2B);
+    _raw_data_frame.AddInt32(HAL_GetTick());
 
     for (uint32_t i = 0; i < _num_slaves; i++)
     {
@@ -410,22 +427,22 @@ void NbusBridge::processRunningState()
         {
             for (uint32_t k = 1; k <= slave->nbus_get_sensor_count(false); k++)
             {
-                _dataFrame->AddInt8(slave->getModuleAddress());
-                _workerFrame = slave->nbus_sensor_getData(k);
-                slaveFrameResponse = _workerFrame->GetFrame();
-                _dataFrame->AddInt8(slave->getSensorAddress());
-                _dataFrame->AddArray(&slaveFrameResponse[3], _workerFrame->GetLength() - 3);
+                _raw_data_frame.AddInt8(slave->getModuleAddress());
+                _worker_frame_ptr = slave->nbus_sensor_getData(k);
+                slaveFrameResponse = _worker_frame_ptr->GetFrame();
+                _raw_data_frame.AddInt8(slave->getSensorAddress());
+                _raw_data_frame.AddArray(&slaveFrameResponse[3], _worker_frame_ptr->GetLength() - 3);
             }
         }
     }
 
-    _dataFrame->AddInt8(0xFF);
-    _dataFrame->AddInt8(0xFF);
-    _dataFrame->Commit();
+    _raw_data_frame.AddInt8(0xFF);
+    _raw_data_frame.AddInt8(0xFF);
+    _raw_data_frame.Commit();
     // TODO problem: v stavi RUNNING pride STOP prikaz, ale ten sa nespracuje, pretoze bezi obsluha tejto funkcie.
     if (_run_state == STATE_RUNNING)
     {
-        sendResponseToMaster(_dataFrame);
+        _communicator->sendToMaster(&_raw_data_frame);
     }
 
     /// TODO toto sa MI NEPACI, TREBA VYRIESIT INAK!!!!!!

Core/Src/NbusCommunicator.cpp

@@ -8,25 +8,9 @@
 #include "NbusCommunicator.h"
 
 NbusCommunicator::NbusCommunicator(UART_HandleTypeDef *uartUbus, UART_HandleTypeDef *uartMaster)
+: _packet_tx(_data_packet_tx, NBUS_MAX_FRAME_SIZE, TYPE_PLAIN, CRC_ON),
+  _packet_rx(_data_packet_rx, NBUS_MAX_FRAME_SIZE, TYPE_PLAIN, CRC_OFF)
 {
-    _packet_tx = new DataFrame(_data_packet_tx, sizeof(_data_packet_tx), TYPE_PLAIN, CRC_ON);
-    if (_packet_tx == NULL)
-    {
-        while (1)
-        {
-            __NOP();
-        }
-    }
-
-    _packet_rx = new DataFrame(_data_packet_rx, sizeof(_data_packet_rx), TYPE_PLAIN, CRC_OFF);
-    if (_packet_rx == NULL)
-    {
-        while (1)
-        {
-            __NOP();
-        }
-    }
-
     if (uartUbus == NULL)
     {
         while (1)
@@ -62,49 +46,52 @@ void NbusCommunicator::_receive()
     HAL_StatusTypeDef status = HAL_UARTEx_ReceiveToIdle(_uart_nbus, _data_packet_comm, NBUS_MAX_FRAME_SIZE,
                                                         &received_size, UART_NBUS_RX_TIMEOUT);
 
-    _packet_rx->Init();
+    _packet_rx.Init();
 
     if (status == HAL_OK)
     {
         if (received_size > 0)
         {
-            _packet_rx->FromArray(_data_packet_comm, received_size);
+            _packet_rx.FromArray(_data_packet_comm, received_size);
         }
     }
 
     HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_RESET);
 
-    _packet_rx->Commit();
+    _packet_rx.Commit();
 }
 
 DataFrame *NbusCommunicator::sendAndReceive(Nbus_pdu *pdu, uint8_t *data, uint8_t data_len)
 {
     this->send(pdu, data, data_len);
     this->_receive();
-    return _packet_rx;
+    return &_packet_rx;
 }
 
 void NbusCommunicator::send(Nbus_pdu *pdu, uint8_t *data, uint8_t data_len)
 {
-    _packet_tx->Init();
-    _packet_tx->AddInt8(pdu->ma); // Module address
-    _packet_tx->AddInt8(pdu->sa); // Slave address
-    _packet_tx->AddInt8(pdu->fc); // Function Code
+    _packet_tx.Init();
+    _packet_tx.AddInt8(pdu->ma); // Module address
+    _packet_tx.AddInt8(pdu->sa); // Slave address
+    _packet_tx.AddInt8(pdu->fc); // Function Code
     for (int i = 0; i < data_len; i++)
     {
-        _packet_tx->AddInt8(data[i]);
+        _packet_tx.AddInt8(data[i]);
     }
 
-    int length = _packet_tx->Commit();
+    int length = _packet_tx.Commit();
 
     HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_SET);
-    HAL_UART_Transmit(_uart_nbus, _packet_tx->GetFrame(), length, 10);
+    HAL_UART_Transmit(_uart_nbus, _packet_tx.GetFrame(), length, 10);
     HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_RESET);
 }
 
 void NbusCommunicator::sendToMaster(DataFrame *master_frame)
 {
-    while (_uart_master->gState != HAL_UART_STATE_READY)
+	if (master_frame == nullptr || master_frame->IsEmpty())
+		return;
+
+	while (_uart_master->gState != HAL_UART_STATE_READY)
     {
         __NOP(); // cakanie na ukoncenie prebiehajuceho odosielania
                  // tu to moze byt vcelku tesno odoslany dalsi paket. je tam pauza o dlzke 1.2bit
@@ -112,39 +99,3 @@ void NbusCommunicator::sendToMaster(DataFrame *master_frame)
 
     HAL_UART_Transmit_DMA(_uart_master, master_frame->GetFrame(), master_frame->GetLength());
 }
-
-/**
- * Informácia o existujúcih moduloch nBus Slave.
- * Formát: [index1 adresa1 index2 adresa2 ...  indexN andresaN]
- */
-DataFrame *NbusCommunicator::formatSlaveInfo(uint8_t rx_frame[], uint8_t slave_address[], uint8_t num)
-{
-    _packet_rx->Init();
-
-    _packet_rx->AddArray(rx_frame, 3);
-    for (uint8_t i = 0; i < num; i++)
-    {
-        _packet_rx->AddInt8(i + 1);
-        _packet_rx->AddInt8(slave_address[i]);
-    }
-    _packet_rx->Commit();
-
-    return _packet_rx;
-}
-
-/**
- * Informácia o existujúcih moduloch nBus Slave.
- * Formát: [index1 adresa1 index2 adresa2 ...  indexN andresaN]
- */
-DataFrame *NbusCommunicator::formatPacket(uint8_t *rxFrame, uint8_t size)
-{
-    _packet_rx->Init();
-
-    for (uint8_t i = 0; i < size; i++)
-    {
-        _packet_rx->AddInt8(rxFrame[i]);
-    }
-    _packet_rx->Commit();
-
-    return _packet_rx;
-}

nbus-bridge.launch

@@ -43,7 +43,7 @@
     <stringAttribute key="com.st.stm32cube.ide.mcu.debug.stlink.stlink_txt_serial_number" value=""/>
     <stringAttribute key="com.st.stm32cube.ide.mcu.debug.stlink.watchdog_config" value="none"/>
     <booleanAttribute key="com.st.stm32cube.ide.mcu.debug.stlinkenable_rtos" value="false"/>
-    <stringAttribute key="com.st.stm32cube.ide.mcu.debug.stlinkrestart_configurations" value="{&quot;fVersion&quot;:1,&quot;fItems&quot;:[{&quot;fDisplayName&quot;:&quot;Reset&quot;,&quot;fIsSuppressible&quot;:false,&quot;fResetAttribute&quot;:&quot;Software system reset&quot;,&quot;fResetStrategies&quot;:[{&quot;fDisplayName&quot;:&quot;Software system reset&quot;,&quot;fLaunchAttribute&quot;:&quot;system_reset&quot;,&quot;fGdbCommands&quot;:[&quot;monitor reset\n&quot;],&quot;fCmdOptions&quot;:[&quot;-g&quot;]},{&quot;fDisplayName&quot;:&quot;Hardware reset&quot;,&quot;fLaunchAttribute&quot;:&quot;hardware_reset&quot;,&quot;fGdbCommands&quot;:[&quot;monitor reset hardware\n&quot;],&quot;fCmdOptions&quot;:[&quot;-g&quot;]},{&quot;fDisplayName&quot;:&quot;Core reset&quot;,&quot;fLaunchAttribute&quot;:&quot;core_reset&quot;,&quot;fGdbCommands&quot;:[&quot;monitor reset core\n&quot;],&quot;fCmdOptions&quot;:[&quot;-g&quot;]},{&quot;fDisplayName&quot;:&quot;None&quot;,&quot;fLaunchAttribute&quot;:&quot;no_reset&quot;,&quot;fGdbCommands&quot;:[],&quot;fCmdOptions&quot;:[&quot;-g&quot;]}],&quot;fGdbCommandGroup&quot;:{&quot;name&quot;:&quot;Additional commands&quot;,&quot;commands&quot;:[]},&quot;fStartApplication&quot;:true}]}"/>
+    <stringAttribute key="com.st.stm32cube.ide.mcu.debug.stlinkrestart_configurations" value="{&quot;fVersion&quot;:1,&quot;fItems&quot;:[{&quot;fDisplayName&quot;:&quot;Reset&quot;,&quot;fIsSuppressible&quot;:false,&quot;fResetAttribute&quot;:&quot;Software system reset&quot;,&quot;fResetStrategies&quot;:[{&quot;fDisplayName&quot;:&quot;Software system reset&quot;,&quot;fLaunchAttribute&quot;:&quot;system_reset&quot;,&quot;fGdbCommands&quot;:[&quot;monitor reset\r\n&quot;],&quot;fCmdOptions&quot;:[&quot;-g&quot;]},{&quot;fDisplayName&quot;:&quot;Hardware reset&quot;,&quot;fLaunchAttribute&quot;:&quot;hardware_reset&quot;,&quot;fGdbCommands&quot;:[&quot;monitor reset hardware\r\n&quot;],&quot;fCmdOptions&quot;:[&quot;-g&quot;]},{&quot;fDisplayName&quot;:&quot;Core reset&quot;,&quot;fLaunchAttribute&quot;:&quot;core_reset&quot;,&quot;fGdbCommands&quot;:[&quot;monitor reset core\r\n&quot;],&quot;fCmdOptions&quot;:[&quot;-g&quot;]},{&quot;fDisplayName&quot;:&quot;None&quot;,&quot;fLaunchAttribute&quot;:&quot;no_reset&quot;,&quot;fGdbCommands&quot;:[],&quot;fCmdOptions&quot;:[&quot;-g&quot;]}],&quot;fGdbCommandGroup&quot;:{&quot;name&quot;:&quot;Additional commands&quot;,&quot;commands&quot;:[]},&quot;fStartApplication&quot;:true}]}"/>
     <booleanAttribute key="com.st.stm32cube.ide.mcu.rtosproxy.enableRtosProxy" value="false"/>
     <stringAttribute key="com.st.stm32cube.ide.mcu.rtosproxy.rtosProxyCustomProperties" value=""/>
     <stringAttribute key="com.st.stm32cube.ide.mcu.rtosproxy.rtosProxyDriver" value="threadx"/>