Xsens / Mbed 2 deprecated MTi-1_fwu_example

Example for updating the MTi-1's firmware. Uses a platform independent, retargetable pure C implementation of the firmware updater protocol.

Dependencies:   mbed-rtos mbed

Important Information

This example is deprecated and no longer maintained. There are new embedded examples available in the MT SDK folder of the MT Software Suite. For more information please visit: https://xsenstechnologies.force.com/knowledgebase/s/article/Introduction-to-the-MT-SDK-programming-examples-for-MTi-devices

Overview

The purpose of this example is to demonstrate how to update the firmware of an MTi-1 series module using the FwUpdate library. The FwUpdate library is provided as C source in the xbus directory. It is setup to be platform independent and easily retargetable. The user must provide an instance of the FwUpdate struct having the platform specific callback function filled in. Refer to fwupdate.h for more information.

The example embeds an Xsens Firmware File (XFF). The XFF used is the official 1.1.1 MTi1-series firmware release. If needed binary copies of specific firmware files can be requested through our support department. We used srecord to convert the XFF to the C data array (See xffdata.c and xffdata.h). When using requested Xsens provided XFF file use srecord as follows:

srec_cat firmware.xff -binary -o xffdata.c -C-array g_xffData -include


This example updates the firmware only. The eMTS (extended Motion Tracker Settings) are not updated. This means that in rare cases (e.g. when hardware filter parameters are updated), you do not take full advantage of the filter update. Most functionality, such as filter behavior, outputs, output formats and communication options are updated with this example. Please use the Windows/Linux FW updater when HW parameters are updated (see release notes to check if HW parameters were changed).

Communication with the MTi-1 series device is implemented using a either a full-duplex UART, I2C or SPI bus. A reset line is used to reset the MTi during initialization. Data is output to a host PC terminal using a second UART.

Supported Platforms

The program has been tested on the following mbed platforms:

Porting to other mbed platforms is relatively be easy by adding its specific port information to board.h. It is however necessary that the board has sufficient code flash/ROM to keep a copy of the XFF (150K). In case you store the XFF data in a different memory (e.g. an external memory) you must re-implement the readXffData callback function.

Using the Example

  1. To use the example program connect one of the supported mbed boards to the host PC and download the application from the mbed online compiler to the target device.
  2. With the mbed board unpowered (USB disconnected) wire the mbed board to the MTi-1 development board. The following connections are required:
    • In all cases:
      • 5V (or 3V3) main supply to VDD (P300-1)
      • MCU IO voltage (IORef) to VDDIO (P300-2)
      • GND to GND (P300-3)
      • MT_NRESET to nRST P(300-5)
    • For I2C communication:
      • MT_SCL to I2C_SCL (P300-9)
      • MT_SDA to I2C_SDA (P300-11)
      • MT_DRDY to DRDY (P300-15)
      • MT_ADD0 to ADD0 (P300-17)
      • MT_ADD1 to ADD0 (P300-19)
      • MT_ADD2 to ADD0 (P300-21)
    • For SPI communication:
      • MT_DRDY to DRDY (P300-15)
      • MT_SCLK to SPI_SCK (P300-17)
      • MT_MISO to SPI_MISO (P300-19)
      • MT_MOSI to SPI_MOSI (P300-21)
      • MT_nCS to SPI_nCS (P300-23)
    • For UART communication:
      • MT_RX to UART_TX (P300-9)
      • MT_TX to UART_RX (P300-11)

Information

Check the defines in board.h to determine which IO pins are used for the MT_xxx connections on each mbed platform.

Information

The active peripheral (I2C, SPI or UART) is selected on the MTi-1 development board through the PSEL0 and PSEL1 switches. Look on the bottom of the development board for the correct settings.

  1. Connect to the target using a serial terminal. The application is configured for:
    • Baudrate = 921600
    • Stop bits = 1
    • No parity bits
    • No flow control
  2. Reset the mbed board.
  3. You should be presented with a simple user interface as shown below: 
Embedded firmware updater example
Interface: I2C

h: Print this text
c: GotoConfig
m: GotoMeasurement
r: Soft reset the module
b: GotoBootloader
v: Request firmware revision
d: Request deviceId
u: Start firmware update (make sure module is in bootloader mode)
x: Hard reset the module and make it stay in bootloader

To do a firmware update

  • Make the MTi-1 enter bootloader mode. Either through 'b' or 'x'
  • You can check if the MTi-1 is in bootloader by requesting the firmware revision ('v'). The bootloader revision always starts with 255
  • Press 'u' to start the firmware update
  • After about 20 seconds the "Firmware update ready" message should appear indicating the update succeeded
  • The device should automatically reboot into its application firmware (use 'v' to verify)

mtinterface/mtinterface.cpp@3:93d0057b0690, 2015-12-22 (annotated)

Committer:
tjerkhofmeijer
Date:
Tue Dec 22 12:34:39 2015 +0100
Revision:
3:93d0057b0690
Parent:
0:6fca643f1aff
Child:
5:63985ca16eb9
The example is now able to detect which baudrate the module is configured for

when using UART communication. Supported baudrates are 921600 and 115200.

When the module is not in bootloader mode no attempt to start the firmware

update procedure is made anymore

Who changed what in which revision?

UserRevisionLine numberNew contents of line
tjerkhofmeijer 0:6fca643f1aff 1 /*!
tjerkhofmeijer 0:6fca643f1aff 2 * \file
tjerkhofmeijer 0:6fca643f1aff 3 * \copyright Copyright (C) Xsens Technologies B.V., 2015.
tjerkhofmeijer 0:6fca643f1aff 4 *
tjerkhofmeijer 0:6fca643f1aff 5 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
tjerkhofmeijer 0:6fca643f1aff 6 * use this file except in compliance with the License. You may obtain a copy
tjerkhofmeijer 0:6fca643f1aff 7 * of the License at
tjerkhofmeijer 0:6fca643f1aff 8 *
tjerkhofmeijer 0:6fca643f1aff 9 * http://www.apache.org/licenses/LICENSE-2.0
tjerkhofmeijer 0:6fca643f1aff 10 *
tjerkhofmeijer 0:6fca643f1aff 11 * Unless required by applicable law or agreed to in writing, software
tjerkhofmeijer 0:6fca643f1aff 12 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
tjerkhofmeijer 0:6fca643f1aff 13 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
tjerkhofmeijer 0:6fca643f1aff 14 * License for the specific language governing permissions and limitations
tjerkhofmeijer 0:6fca643f1aff 15 * under the License.
tjerkhofmeijer 0:6fca643f1aff 16 */
tjerkhofmeijer 0:6fca643f1aff 17 #include "mtinterface.h"
tjerkhofmeijer 0:6fca643f1aff 18 #include <stdlib.h>
tjerkhofmeijer 0:6fca643f1aff 19 #include <assert.h>
tjerkhofmeijer 0:6fca643f1aff 20
tjerkhofmeijer 0:6fca643f1aff 21
tjerkhofmeijer 3:93d0057b0690 22 #define XBUS_ERROR_MID 0x42
tjerkhofmeijer 3:93d0057b0690 23
tjerkhofmeijer 0:6fca643f1aff 24 /*! \class MtInterface
tjerkhofmeijer 0:6fca643f1aff 25 \brief Abstract interface for communicating with an Xsens Motion Tracker (MT) on an mbed platform
tjerkhofmeijer 0:6fca643f1aff 26
tjerkhofmeijer 0:6fca643f1aff 27 MtInterface defines an abstract interface for communicating with a Motion Tracker (MT) via xbus
tjerkhofmeijer 0:6fca643f1aff 28 messages. Depending on the type of communication interface a specific implementation
tjerkhofmeijer 0:6fca643f1aff 29 must be made which inherits from MtInterface.
tjerkhofmeijer 0:6fca643f1aff 30 */
tjerkhofmeijer 0:6fca643f1aff 31
tjerkhofmeijer 0:6fca643f1aff 32 static MtInterface* g_thisPtr = 0;
tjerkhofmeijer 0:6fca643f1aff 33
tjerkhofmeijer 0:6fca643f1aff 34
tjerkhofmeijer 0:6fca643f1aff 35 /*! \brief Callback function for XbusParserCallback for allocating a block of memory
tjerkhofmeijer 0:6fca643f1aff 36 \param bufferSize buffer size
tjerkhofmeijer 0:6fca643f1aff 37 */
tjerkhofmeijer 0:6fca643f1aff 38 static void *allocateMessageDataWrapper(size_t bufferSize)
tjerkhofmeijer 0:6fca643f1aff 39 {
tjerkhofmeijer 0:6fca643f1aff 40 return g_thisPtr->allocateMessageData(bufferSize);
tjerkhofmeijer 0:6fca643f1aff 41 }
tjerkhofmeijer 0:6fca643f1aff 42
tjerkhofmeijer 0:6fca643f1aff 43
tjerkhofmeijer 0:6fca643f1aff 44 /*! \brief Callback function for XbusParserCallback for deallocating a block of memory
tjerkhofmeijer 0:6fca643f1aff 45 \param buffer Pointer to the buffer that should be deallocated
tjerkhofmeijer 0:6fca643f1aff 46 */
tjerkhofmeijer 0:6fca643f1aff 47 static void deallocateMessageDataWrapper(void const *buffer)
tjerkhofmeijer 0:6fca643f1aff 48 {
tjerkhofmeijer 0:6fca643f1aff 49 g_thisPtr->deallocateMessageData(buffer);
tjerkhofmeijer 0:6fca643f1aff 50 }
tjerkhofmeijer 0:6fca643f1aff 51
tjerkhofmeijer 0:6fca643f1aff 52
tjerkhofmeijer 0:6fca643f1aff 53 /*! \brief Callback function for XbusParserCallback that handles completely received xbus messages from the motion tracker
tjerkhofmeijer 0:6fca643f1aff 54 \param Pointer to the received xbus message
tjerkhofmeijer 0:6fca643f1aff 55 */
tjerkhofmeijer 0:6fca643f1aff 56 static void xbusParserCallbackFunctionWrapper(struct XbusMessage const *message)
tjerkhofmeijer 0:6fca643f1aff 57 {
tjerkhofmeijer 0:6fca643f1aff 58 g_thisPtr->xbusParserCallbackFunction(message);
tjerkhofmeijer 0:6fca643f1aff 59 }
tjerkhofmeijer 0:6fca643f1aff 60
tjerkhofmeijer 0:6fca643f1aff 61
tjerkhofmeijer 0:6fca643f1aff 62 /*! \brief Constructs an MtInterface.
tjerkhofmeijer 0:6fca643f1aff 63 * \note Only a single instance of MtInterface is allowed
tjerkhofmeijer 0:6fca643f1aff 64 */
tjerkhofmeijer 0:6fca643f1aff 65 MtInterface::MtInterface()
tjerkhofmeijer 0:6fca643f1aff 66 {
tjerkhofmeijer 0:6fca643f1aff 67 assert(g_thisPtr == 0);
tjerkhofmeijer 0:6fca643f1aff 68 g_thisPtr = this;
tjerkhofmeijer 0:6fca643f1aff 69
tjerkhofmeijer 0:6fca643f1aff 70 // Create an xbusParser:
tjerkhofmeijer 0:6fca643f1aff 71 XbusParserCallback xbusCallback = {};
tjerkhofmeijer 0:6fca643f1aff 72 xbusCallback.allocateBuffer = allocateMessageDataWrapper;
tjerkhofmeijer 0:6fca643f1aff 73 xbusCallback.deallocateBuffer = deallocateMessageDataWrapper;
tjerkhofmeijer 0:6fca643f1aff 74 xbusCallback.handleMessage = xbusParserCallbackFunctionWrapper;
tjerkhofmeijer 0:6fca643f1aff 75 m_xbusParser = XbusParser_create(&xbusCallback);
tjerkhofmeijer 0:6fca643f1aff 76 }
tjerkhofmeijer 0:6fca643f1aff 77
tjerkhofmeijer 0:6fca643f1aff 78
tjerkhofmeijer 0:6fca643f1aff 79 /*! \brief Destructor
tjerkhofmeijer 0:6fca643f1aff 80 */
tjerkhofmeijer 0:6fca643f1aff 81 MtInterface::~MtInterface()
tjerkhofmeijer 0:6fca643f1aff 82 {
tjerkhofmeijer 0:6fca643f1aff 83 g_thisPtr = 0;
tjerkhofmeijer 0:6fca643f1aff 84 }
tjerkhofmeijer 0:6fca643f1aff 85
tjerkhofmeijer 0:6fca643f1aff 86
tjerkhofmeijer 0:6fca643f1aff 87 /*! \brief Returns the next message from the rx queue or NULL if the queue is empty
tjerkhofmeijer 0:6fca643f1aff 88 \note The caller must dealocate the message with releaseXbusMessage() after use.
tjerkhofmeijer 0:6fca643f1aff 89 */
tjerkhofmeijer 0:6fca643f1aff 90 XbusMessage *MtInterface::getXbusMessage()
tjerkhofmeijer 0:6fca643f1aff 91 {
tjerkhofmeijer 0:6fca643f1aff 92 XbusMessage *xbusMessage = NULL;
tjerkhofmeijer 0:6fca643f1aff 93 osEvent ev = m_xbusRxQueue.get(1);
tjerkhofmeijer 0:6fca643f1aff 94 if (ev.status == osEventMessage)
tjerkhofmeijer 0:6fca643f1aff 95 {
tjerkhofmeijer 0:6fca643f1aff 96 xbusMessage = (XbusMessage*)ev.value.p;
tjerkhofmeijer 0:6fca643f1aff 97 }
tjerkhofmeijer 0:6fca643f1aff 98 return xbusMessage;
tjerkhofmeijer 0:6fca643f1aff 99 }
tjerkhofmeijer 0:6fca643f1aff 100
tjerkhofmeijer 0:6fca643f1aff 101
tjerkhofmeijer 0:6fca643f1aff 102 /*! \brief Releases an xbus message previously obtained by a call to getXbusMessage()
tjerkhofmeijer 0:6fca643f1aff 103 \param xbusMessage that should be released
tjerkhofmeijer 0:6fca643f1aff 104 */
tjerkhofmeijer 0:6fca643f1aff 105 void MtInterface::releaseXbusMessage(XbusMessage *xbusMessage)
tjerkhofmeijer 0:6fca643f1aff 106 {
tjerkhofmeijer 0:6fca643f1aff 107 if (xbusMessage != NULL)
tjerkhofmeijer 0:6fca643f1aff 108 {
tjerkhofmeijer 0:6fca643f1aff 109 deallocateMessageData(xbusMessage->m_data);
tjerkhofmeijer 0:6fca643f1aff 110 m_xbusMessagePool.free(xbusMessage);
tjerkhofmeijer 0:6fca643f1aff 111 }
tjerkhofmeijer 0:6fca643f1aff 112 }
tjerkhofmeijer 0:6fca643f1aff 113
tjerkhofmeijer 0:6fca643f1aff 114
tjerkhofmeijer 0:6fca643f1aff 115 /*! \brief Callback function for XbusParserCallback to allocate a block of memory
tjerkhofmeijer 0:6fca643f1aff 116 \param bufferSize buffer size
tjerkhofmeijer 0:6fca643f1aff 117 */
tjerkhofmeijer 0:6fca643f1aff 118 void *MtInterface::allocateMessageData(size_t bufferSize)
tjerkhofmeijer 0:6fca643f1aff 119 {
tjerkhofmeijer 0:6fca643f1aff 120 assert(bufferSize < m_rxBufferSize);
tjerkhofmeijer 0:6fca643f1aff 121 void *ptr = m_memoryPool.alloc();
tjerkhofmeijer 0:6fca643f1aff 122 assert(ptr);
tjerkhofmeijer 0:6fca643f1aff 123 return ptr;
tjerkhofmeijer 0:6fca643f1aff 124 }
tjerkhofmeijer 0:6fca643f1aff 125
tjerkhofmeijer 0:6fca643f1aff 126
tjerkhofmeijer 0:6fca643f1aff 127 /*! \brief Callback function for XbusParserCallback to deallocate a block of memory
tjerkhofmeijer 0:6fca643f1aff 128 \param buffer Pointer to the buffer that should be deallocated
tjerkhofmeijer 0:6fca643f1aff 129 */
tjerkhofmeijer 0:6fca643f1aff 130 void MtInterface::deallocateMessageData(void const *buffer)
tjerkhofmeijer 0:6fca643f1aff 131 {
tjerkhofmeijer 0:6fca643f1aff 132 m_memoryPool.free((uint8_t(*)[m_rxBufferSize])buffer);
tjerkhofmeijer 0:6fca643f1aff 133 }
tjerkhofmeijer 0:6fca643f1aff 134
tjerkhofmeijer 0:6fca643f1aff 135
tjerkhofmeijer 0:6fca643f1aff 136 /*! \brief Callback function for XbusParserCallback that handles a completely received xbus message from the motion tracker
tjerkhofmeijer 0:6fca643f1aff 137 \param message Pointer to the received xbus message
tjerkhofmeijer 0:6fca643f1aff 138 */
tjerkhofmeijer 0:6fca643f1aff 139 void MtInterface::xbusParserCallbackFunction(struct XbusMessage const *message)
tjerkhofmeijer 0:6fca643f1aff 140 {
tjerkhofmeijer 0:6fca643f1aff 141 XbusMessage *xbusMessage = m_xbusMessagePool.alloc();
tjerkhofmeijer 0:6fca643f1aff 142 assert(xbusMessage);
tjerkhofmeijer 0:6fca643f1aff 143 memcpy(xbusMessage, message, sizeof(XbusMessage));
tjerkhofmeijer 0:6fca643f1aff 144 m_xbusRxQueue.put(xbusMessage);
tjerkhofmeijer 0:6fca643f1aff 145 }
tjerkhofmeijer 0:6fca643f1aff 146
tjerkhofmeijer 3:93d0057b0690 147 /*! \brief Sends an Xbus message and waits for the related acknowledge
tjerkhofmeijer 3:93d0057b0690 148 \returns 0 if no related message was received. Pointer to the message otherwise. This message can also be an error message.
tjerkhofmeijer 3:93d0057b0690 149 */
tjerkhofmeijer 3:93d0057b0690 150 XbusMessage* MtInterface::sendAndWait(const XbusMessage* xbusMessage)
tjerkhofmeijer 3:93d0057b0690 151 {
tjerkhofmeijer 3:93d0057b0690 152 sendXbusMessage(xbusMessage);
tjerkhofmeijer 3:93d0057b0690 153 Timer timer;
tjerkhofmeijer 3:93d0057b0690 154 timer.start();
tjerkhofmeijer 3:93d0057b0690 155 bool waiting = true;
tjerkhofmeijer 3:93d0057b0690 156
tjerkhofmeijer 3:93d0057b0690 157 uint8_t expectedMid = xbusMessage->m_mid + 1;
tjerkhofmeijer 3:93d0057b0690 158
tjerkhofmeijer 3:93d0057b0690 159 while(waiting && (timer.read() < 1.0))
tjerkhofmeijer 3:93d0057b0690 160 {
tjerkhofmeijer 3:93d0057b0690 161 process();
tjerkhofmeijer 3:93d0057b0690 162 XbusMessage* xbusMessage = getXbusMessage();
tjerkhofmeijer 3:93d0057b0690 163 if (xbusMessage)
tjerkhofmeijer 3:93d0057b0690 164 {
tjerkhofmeijer 3:93d0057b0690 165 if (xbusMessage->m_mid == expectedMid || xbusMessage->m_mid == XBUS_ERROR_MID)
tjerkhofmeijer 3:93d0057b0690 166 {
tjerkhofmeijer 3:93d0057b0690 167 return xbusMessage;
tjerkhofmeijer 3:93d0057b0690 168 }
tjerkhofmeijer 3:93d0057b0690 169 releaseXbusMessage(xbusMessage);
tjerkhofmeijer 3:93d0057b0690 170 }
tjerkhofmeijer 3:93d0057b0690 171 }
tjerkhofmeijer 3:93d0057b0690 172
tjerkhofmeijer 3:93d0057b0690 173 return NULL;
tjerkhofmeijer 3:93d0057b0690 174 }
tjerkhofmeijer 3:93d0057b0690 175