WebSVN – MLAB – /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src Rev 2060 and /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src Rev 2061 – Path Comparison

No changes between revisions

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/Crs232/rs232.cpp
 ,0 → 1,494
+/******************** (C) COPYRIGHT 2010 STMicroelectronics ********************
+* File Name          : rs232.cpp
+* Author             : MCD Application Team
+* Version            : v2.2.0
+* Date               : 05/03/2010
+* Description        : Implements the RS232 class for COM communication
+********************************************************************************
+* THE PRESENT SOFTWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
+* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
+* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
+* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
+* CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
+* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+*******************************************************************************/
+#include <windows.h>
+#include <stdio.h>
+#include <string.h>
+#include "rs232.h"
+///  set serial communication over COM1 with 115200 Bauds, 8 bitand no parity.
+CRS232::CRS232()
+{
+        hcom = NULL;
+        bufferSize = 2048;
+        numPort     = 1;
+        speedInBaud = 115200;
+        nbBit       = 8;
+        parity      = 2;
+        nbStopBit   = 1;
+        isConnected = FALSE;
+        bEcho =0;
+        FlowControl = FALSE;
+}
+CRS232::~CRS232()
+{
+        if(hcom != NULL)
+                closeCom();
+}
+void CRS232::SetComSettings(int _numPort, long _speedInBaud, int _nbBit, int _parity, float _nbStopBit)
+{
+         numPort     = _numPort;
+         speedInBaud = _speedInBaud;
+         nbBit       = _nbBit;
+         parity      = _parity;
+         nbStopBit   = _nbStopBit;
+}
+bool CRS232::open()
+{
+        char buf[] = "\\\\.\\COM1";
+        if(numPort<1 || numPort>999)
+                return false;
+        if(speedInBaud<1)
+                return false;
+        if(nbBit<5 || nbBit > 9)
+                return false;
+        if(parity<0 || parity > 2)
+                return false;
+        if(nbStopBit<1 || nbStopBit > 2)
+                return false;
+        itoa(numPort, &buf[7], 10);
+        hcom=CreateFile(buf, GENERIC_READ | GENERIC_WRITE , 0, NULL, OPEN_EXISTING , 0, NULL);
+        if (hcom==0 || hcom==INVALID_HANDLE_VALUE)
+                return false;
+        isConnected = TRUE;
+        setTimeOut(5000);
+        if ( !SetupComm(hcom, bufferSize, bufferSize) )
+            return false;
+    if ( !GetCommState(hcom, &dcb))
+                return false;
+        dcb.BaudRate = speedInBaud;
+        dcb.ByteSize = nbBit;
+        if(nbStopBit == 1)
+                dcb.StopBits = ONESTOPBIT;
+        if(nbStopBit == 1.5)
+                dcb.StopBits = ONE5STOPBITS;
+        if(nbStopBit == 2)
+                dcb.StopBits = TWOSTOPBITS;
+        if(parity == 0)
+                dcb.Parity = NOPARITY;
+        if(parity == 1)
+                dcb.Parity = ODDPARITY;
+        if(parity == 2)
+                dcb.Parity = EVENPARITY;
+    if ( FlowControl == true)
+    {
+      dcb.fDtrControl = DTR_CONTROL_ENABLE;
+          dcb.fRtsControl = RTS_CONTROL_ENABLE;
+    }
+        else
+        {
+          dcb.fDtrControl = DTR_CONTROL_DISABLE;
+          dcb.fRtsControl = RTS_CONTROL_DISABLE;
+        }
+          if (!SetCommState(hcom, &dcb))
+                return false;
+          else
+                return true;
+}
+void CRS232::closeCom()
+{
+        CloseHandle(hcom);
+        hcom = NULL;
+        isConnected = FALSE;
+}
+bool CRS232::setTimeOut(DWORD ms)
+{
+        if( ms<0)
+                return false;
+        ct.ReadIntervalTimeout = ms;
+        ct.ReadTotalTimeoutMultiplier = ms;
+        ct.ReadTotalTimeoutConstant = ms;
+        ct.WriteTotalTimeoutMultiplier = ms;
+        ct.WriteTotalTimeoutConstant = ms;
+        if ( !SetCommTimeouts(hcom, &ct) )
+                return false;
+        return false;
+        //MSDN: The SetCommTimeouts function sets the time-out parameters for all read and write operations on a specified communications device.
+}
+bool CRS232::setSpeed(DWORD baudrate)
+{
+        if( baudrate<1)
+                return false;
+        if (!GetCommState(hcom, &dcb))
+                return FALSE;
+        dcb.BaudRate = baudrate;
+        if (!SetCommState(hcom, &dcb))
+                return FALSE;
+        else
+                return TRUE;
+        //MSDN: The SetCommState function configures a communications device according to the specifications in a device-control block (a DCB structure). The function reinitializes all hardware and control settings, but it does not empty output or input queues.
+}
+int  CRS232::sendData(string* data)
+{
+        if( data == NULL )
+                return false;
+        return sendData((DWORD)data->size(), (LPBYTE)data->data());
+}
+int CRS232::sendData(DWORD lg, LPBYTE data)
+{
+        DWORD result=0;
+        DWORD result1=0;
+        DWORD counter =0;
+        if( lg<0 || data==NULL)
+                return false;
+    if  ( bEcho == 2)
+        {
+           for ( counter =0 ; counter <  lg ; counter ++)
+                 {
+                        if ( !WriteFile(hcom, data+counter, 1, &result1, 0) )
+                        return -1;
+                        if( lg<0 || data==NULL)
+                    return false;
+                     if (!ReadFile(hcom, data+counter, 1, &result, 0))
+                         return -1;
+                 }
+                 return (counter);
+    }
+        else
+        {
+          if ( !WriteFile(hcom, data, lg, &result, 0) )
+                return -1;
+          else
+                return (int)result;
+    }
+        //MSDN:  The WriteFile function writes data to a file and is designed for both synchronous
+        //              and asynchronous operation. The function starts writing data to the file at the
+        //              position indicated by the file pointer. After the write operation has been completed
+        //              , the file pointer is adjusted by the number of bytes actually written, except when
+        //              the file is opened with FILE_FLAG_OVERLAPPED. If the file handle was created for
+        //              overlapped input and output (I/O), the application must adjust the position of the
+        //              file pointer after the write operation is finished.
+    //       This function is designed for both synchronous and asynchronous operation.
+        //              The WriteFileEx function is designed solely for asynchronous operation.
+        //              It lets an application perform other processing during a file write operation.
+}
+int CRS232::receiveData(string* data)
+{       char buffer[1025];
+        int nbChar=0;
+        if( data==NULL)
+                return false;
+        nbChar = receiveData(1024, (LPBYTE)buffer);
+        buffer[nbChar] = 0;
+        data->assign(buffer);
+        return nbChar;
+}
+int CRS232::receiveData(DWORD lg, LPBYTE data)
+{
+        DWORD result=0;
+    DWORD result1=0;
+        DWORD counter =0;
+        if( lg<0 || data==NULL)
+                return false;
+    if  ( bEcho == 0)
+        {
+                if (!ReadFile(hcom, data, lg, &result, 0))
+                        return -1;
+                else
+                        return (int)result;
+        }
+        else if  ( bEcho == 1)
+        {
+             for ( counter =0 ; counter <  lg ; counter ++)
+                 {
+                   if (!ReadFile(hcom, data+counter, 1, &result, 0))
+                                return -1;
+                        if( lg<0 || data==NULL)
+                    return false;
+                   if ( !WriteFile(hcom, data+counter, 1, &result1, 0) )
+                            return -1;
+                 }
+                 return (counter);
+        }
+        else if  ( bEcho == 2)
+        {
+                if (!ReadFile(hcom, data, lg, &result, 0))
+                        return -1;
+                else
+                        return (int)result;
+        }
+        else
+        {
+                /* TODO */
+                return -1;
+        }
+        //MSDN:   The ReadFile function reads data from a file, starting at the position indicated
+        //               by the file pointer. After the read operation has been completed, the file pointer
+        //               is adjusted by the number of bytes actually read, unless the file handle is
+        //               created with the overlapped attribute. If the file handle is created for
+        //               overlapped input and output (I/O), the application must adjust the position of
+        //               the file pointer after the read operation.
+        //        This function is designed for both synchronous and asynchronous operation.
+        //               The ReadFileEx function is designed solely for asynchronous operation. It lets
+        //               an application perform other processing during a file read operation.
+}
+/**************************** SetRts(val) **************************************************/
+bool CRS232::setRts(bool val)
+{
+        if(val)
+          {
+                  if(EscapeCommFunction(hcom, SETRTS) == TRUE )
+                          return true;
+          }
+        else
+          {
+                  if(EscapeCommFunction(hcom, CLRRTS) == TRUE )
+                          return true;
+          }
+   return false;
+}
+/**************************** SetTxd(val) ***************************************************/
+bool CRS232::setTxd(bool val)
+{
+        if(val)
+          {
+                  if( EscapeCommFunction(hcom, SETBREAK) == TRUE )
+                          return true;
+          }
+        else
+          {
+                  if( EscapeCommFunction(hcom, CLRBREAK) == TRUE )
+                          return true;
+          }
+   return false;
+}
+/**************************** SetDtr(val) ************************************************** */
+bool CRS232::setDtr(bool val)
+{
+        if(val)
+          {
+                  if( EscapeCommFunction(hcom, SETDTR) == TRUE )
+                          return true;
+          }
+        else
+          {
+                  if( EscapeCommFunction(hcom, CLRDTR) == TRUE )
+                          return false;
+          }
+    return false;
+}
+/********************** GetCts() ***********************/
+bool CRS232::getCts()
+{
+        DWORD result;
+                GetCommModemStatus(hcom, &result);
+                if(result & MS_CTS_ON)
+                        return true;
+                else
+                        return false;
+}
+/********************** GetDtr() ***********************/
+bool CRS232::getDtr()
+{
+  DWORD result;
+                GetCommModemStatus(hcom, &result);
+                if(result & MS_DSR_ON)
+                        return true;
+                else
+                        return false;
+}
+/********************** GetRi() ***********************/
+bool CRS232::getRi()
+{
+  DWORD result;
+                GetCommModemStatus(hcom, &result);
+                if(result & MS_RING_ON)
+                        return true;
+                else
+                        return false;
+}
+/********************** GetCd() ***********************/
+bool CRS232::getCd()
+{ int err=0;
+  DWORD result;
+                err = GetCommModemStatus(hcom, &result);
+                if(result & MS_RLSD_ON)
+                        return true;
+                else
+                        return false;
+}
+string CRS232::getErrorMsg()
+{
+        LPVOID lpMsgBuf;
+        string sErreur = "";
+        if ( FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+                                                        NULL, GetLastError(),
+                                                        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
+                                                        (LPTSTR) &lpMsgBuf, 0, NULL ))
+        {
+                sErreur.assign((LPCTSTR)lpMsgBuf);
+        }
+        return sErreur;
+}
+void CRS232::SetParity(int _parity)
+{
+        if(_parity == 0)
+                dcb.Parity = NOPARITY;
+        if(_parity == 1)
+                dcb.Parity = ODDPARITY;
+        if(_parity == 2)
+                dcb.Parity = EVENPARITY;
+        SetCommState(hcom, &dcb);
+}
+/******************* (C) COPYRIGHT 2010 STMicroelectronics *****END OF FILE******/

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/Crs232/rs232.h
 ,0 → 1,80
+/******************** (C) COPYRIGHT 2010 STMicroelectronics ********************
+* File Name          : rs232.h
+* Author             : MCD Application Team
+* Version            : v2.2.0
+* Date               : 05/03/2010
+* Description        : Defines the RS232 class for COM communication
+********************************************************************************
+* THE PRESENT SOFTWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
+* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
+* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
+* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
+* CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
+* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+*******************************************************************************/
+#ifndef LSERIE_H
+#define LSERIE_H
+#include <string>
+using namespace std;
+class CRS232
+{
+public:
+        void SetParity(int _parity);
+        BOOL isConnected;
+        int numPort;
+        long speedInBaud;
+        int nbBit;
+        int parity;
+        float nbStopBit;
+        int  bEcho ;             /* Echo back for LIN emulation */
+                                 /* 0 : Disabled , 1 : Echo Back , 2 : Listen back */
+    bool FlowControl;
+        //------ CONSTRUCTOR ------
+        CRS232();
+        virtual ~CRS232();
+        //------ OPEN AND CONFIGURE ------
+        void SetComSettings(int _numPort, long _speedInBaud, int _nbBit, int _parity, float _nbStopBit);
+        bool open();    // Open the serial port COM "numPort" at the speed "speedInBaud".
+                                // bauds with and this adjustement : "nbBit" bit / "nbStopBit" stop bit / "parity").
+                                                                                                                // Return: true if success.
+        void closeCom();                                        //Close the serial port.
+        bool setTimeOut(DWORD ms);                                      //Set the time-out for receive data. Return: true if success.
+        bool setSpeed(DWORD baudrate);                          //Set the speed in bauds. Return: true if success.
+        //------ SEND AND RECEIVE DATA ------
+        int sendData(DWORD lg, LPBYTE data);            //Send table "data" of "lg" bytes.  Return: number of bytes really sent.
+        int sendData(string* data);                                     //Send string "data".  Return: number of bytes really sent.
+        int receiveData(DWORD lg, LPBYTE data);         //Receive table "data" who is limit at "lg" bytes.  Return: number of bytes received.
+        int receiveData(string* data);                          //Receive string "data". Return: number of bytes received.
+        //------ READ AND WRITE THE STATE OF THE CONTROL LINE ------
+        bool setRts(bool val);                  // Set the state of RTS. Return: true if success.
+        bool setDtr(bool val);                  // Set the state of DTR. Return: true if success.
+        bool setTxd(bool val);                  // Set the state of TXD. Return: true if success.
+        bool getCts();                                  // Return: The state of CTS.
+        bool getDtr();                                  // Return: The state of DTR.
+        bool getRi();                                   // Return: The state of RI.
+        bool getCd();                                   // Return: The state of CD.
+        string getErrorMsg();                   // Return: The error message generated by the last function.
+private:
+        HANDLE                  hcom;                           //Otput file to the COM port                    | The file stream use for acces to the serial port.
+        _COMMTIMEOUTS   ct;                 //={0,0,0,0,0}; //Config du Time Out        | This variable contain the delay of the time-out.
+        DCB                             dcb;                            //Port configuration struct                             | This object is use in order to configure the serial port.
+        int                             bufferSize;
+};
+#endif
+/******************* (C) COPYRIGHT 2010 STMicroelectronics *****END OF FILE******/

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/Files/Debug/Files.lib
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/Files/Errors.h
 ,0 → 1,45
+/******************** (C) COPYRIGHT 2009 STMicroelectronics ********************
+* File Name          : Errors.h
+* Author             : MCD Application Team
+* Version            : v2.1.0
+* Date               : 11/02/2009
+* Description        : Defines the files Input/Output error codes
+********************************************************************************
+* THE PRESENT SOFTWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
+* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
+* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
+* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
+* CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
+* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+*******************************************************************************/
+#ifndef ERRORS_H
+#define ERRORS_H
+#define FILES_ERROR_OFFSET                              (0x12340000+0x6000)
+#define FILES_NOERROR                                   (0x12340000+0x0000)
+#define FILES_BADSUFFIX                             (FILES_ERROR_OFFSET+0x0002)
+#define FILES_UNABLETOOPENFILE                  (FILES_ERROR_OFFSET+0x0003)
+#define FILES_UNABLETOOPENTEMPFILE              (FILES_ERROR_OFFSET+0x0004)
+#define FILES_BADFORMAT                             (FILES_ERROR_OFFSET+0x0005)
+#define FILES_BADADDRESSRANGE                   (FILES_ERROR_OFFSET+0x0006)
+#define FILES_BADPARAMETER                              (FILES_ERROR_OFFSET+0x0008)
+#define FILES_UNEXPECTEDERROR                   (FILES_ERROR_OFFSET+0x000A)
+#define FILES_FILEGENERALERROR                  (FILES_ERROR_OFFSET+0x000D)
+#define STPRT_ERROR_OFFSET                              (0x12340000+0x5000)
+#define STPRT_NOERROR                                   (0x12340000)
+#define STPRT_UNABLETOLAUNCHTHREAD      (STPRT_ERROR_OFFSET+0x0001)
+#define STPRT_ALREADYRUNNING                    (STPRT_ERROR_OFFSET+0x0007)
+#define STPRT_BADPARAMETER                              (STPRT_ERROR_OFFSET+0x0008)
+#define STPRT_BADFIRMWARESTATEMACHINE   (STPRT_ERROR_OFFSET+0x0009)
+#define STPRT_UNEXPECTEDERROR                   (STPRT_ERROR_OFFSET+0x000A)
+#define STPRT_ERROR                                     (STPRT_ERROR_OFFSET+0x000B)
+#define STPRT_RETRYERROR                                        (STPRT_ERROR_OFFSET+0x000C)
+#define STPRT_UNSUPPORTEDFEATURE                    (STPRT_ERROR_OFFSET+0x000D)
+#endif
+/******************* (C) COPYRIGHT 2009 STMicroelectronics *****END OF FILE******/

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/Files/Files.h
 ,0 → 1,99
+/******************** (C) COPYRIGHT 2009 STMicroelectronics ********************
+* File Name          : Files.h
+* Author             : MCD Application Team
+* Version            : v2.1.0
+* Date               : 11/02/2009
+* Description        : Defines the Files DLL interface
+********************************************************************************
+* THE PRESENT SOFTWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
+* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
+* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
+* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
+* CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
+* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+*******************************************************************************/
+#if !defined(AFX_FILES_H__E07F909F_97B4_4295_8B8F_5EA1A83ECA92__INCLUDED_)
+#define AFX_FILES_H__E07F909F_97B4_4295_8B8F_5EA1A83ECA92__INCLUDED_
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+#ifndef __AFXWIN_H__
+        #error include 'stdafx.h' before including this file for PCH
+#endif
+#include "resource.h"           // main symbols
+#include "FilesInc.h"
+#include "Image.h"
+#include "Errors.h"
+//#include "IniFile.h"
+/////////////////////////////////////////////////////////////////////////////
+// CFilesApp
+// See Files.cpp for the implementation of this class
+//
+class CFilesApp : public CWinApp
+{
+public:
+        CFilesApp();
+// Overrides
+        // ClassWizard generated virtual function overrides
+        //{{AFX_VIRTUAL(CFilesApp)
+        //}}AFX_VIRTUAL
+        //{{AFX_MSG(CFilesApp)
+                // NOTE - the ClassWizard will add and remove member functions here.
+                //    DO NOT EDIT what you see in these blocks of generated code !
+        //}}AFX_MSG
+        DECLARE_MESSAGE_MAP()
+};
+extern "C" DWORD EXPORT FILES_OpenExistingFile(PSTR pPathFile, PHANDLE phFile, PWORD pVid, PWORD pPid, PWORD pBcd,PBYTE pNbImages);
+extern "C" DWORD EXPORT FILES_CreateNewFile(PSTR pPathFile, PHANDLE phFile, WORD Vid, WORD Pid, WORD Bcd);
+extern "C" DWORD EXPORT FILES_CloseFile(HANDLE hFile);
+extern "C" DWORD EXPORT FILES_AppendImageToFile(HANDLE hFile, HANDLE Image);
+extern "C" DWORD EXPORT FILES_ReadImageFromFile(HANDLE hFile, int Rank, PHANDLE pImage);
+extern "C" DWORD EXPORT FILES_ImageFromFile(PSTR pPathFile, PHANDLE pImage, BYTE nAlternate);
+extern "C" DWORD EXPORT FILES_ImageToFile(PSTR pPathFile, HANDLE Image);
+extern "C" DWORD EXPORT FILES_CreateImage(PHANDLE pHandle, BYTE nAlternate);
+extern "C" DWORD EXPORT FILES_CreateImageFromMapping(PHANDLE pHandle, PMAPPING pMapping);
+extern "C" DWORD EXPORT FILES_DuplicateImage(HANDLE hSource, PHANDLE pDest);
+extern "C" DWORD EXPORT FILES_FilterImageForOperation(HANDLE Handle, PMAPPING pMapping, DWORD Operation, BOOL bTruncateLeadFFForUpgrade);
+extern "C" DWORD EXPORT FILES_DestroyImageElement(HANDLE Handle, DWORD dwRank);
+extern "C" DWORD EXPORT FILES_DestroyImage(PHANDLE pHandle);
+extern "C" DWORD EXPORT FILES_GetImageAlternate(HANDLE Handle, PBYTE pAlternate);
+extern "C" DWORD EXPORT FILES_GetImageNbElement(HANDLE Handle, PDWORD pNbElements);
+extern "C" DWORD EXPORT FILES_GetImageName(HANDLE Handle, PSTR Name);
+extern "C" DWORD EXPORT FILES_SetImageName(HANDLE Handle, PSTR Name);
+extern "C" DWORD EXPORT FILES_SetImageElement(HANDLE Handle, DWORD dwRank, BOOL bInsert, IMAGEELEMENT Element);
+extern "C" DWORD EXPORT FILES_GetImageElement(HANDLE Handle, DWORD dwRank, PIMAGEELEMENT pElement);
+extern "C" DWORD EXPORT FILES_GetMemoryMapping(PSTR pPathFile, PWORD Size, PSTR MapName, PWORD PacketSize, PMAPPING pMapping, PBYTE PagesPerSector);
+/*FILES_OpenExistingFile
+  FILES_CreateNewFile
+  FILES_CloseFile
+  FILES_AppendImageToFile
+  FILES_ReadImageFromFile*/
+/////////////////////////////////////////////////////////////////////////////
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+#endif // !defined(AFX_FILES_H__E07F909F_97B4_4295_8B8F_5EA1A83ECA92__INCLUDED_)
+/******************* (C) COPYRIGHT 2009 STMicroelectronics *****END OF FILE******/

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/Files/FilesInc.h
 ,0 → 1,69
+/******************** (C) COPYRIGHT 2009 STMicroelectronics ********************
+* File Name          : FilesInc.h
+* Author             : MCD Application Team
+* Version            : v2.1.0
+* Date               : 11/02/2009
+* Description        : Defines the struct types used by Files DLL
+********************************************************************************
+* THE PRESENT SOFTWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
+* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
+* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
+* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
+* CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
+* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+*******************************************************************************/
+#ifndef FILES_INC_H
+#define FILES_INC_H
+#define OPERATION_DETACH        0
+#define OPERATION_RETURN        1
+#define OPERATION_UPLOAD        2
+#define OPERATION_ERASE         3
+#define OPERATION_DNLOAD        4
+#ifndef TYPE_STATUS
+typedef struct
+{
+        UCHAR bStatus;
+        UCHAR bwPollTimeout[3];
+        UCHAR bState;
+        UCHAR iString;
+}       STATUS,  *PSTATUS;
+#endif
+#define BIT_READABLE    1
+#define BIT_ERASABLE    2
+#define BIT_WRITEABLE   4
+typedef struct {
+        char*       Name;
+    DWORD               dwStartAddress;
+        DWORD           dwAliasedAddress;
+        DWORD           dwSectorIndex;
+        DWORD           dwSectorSize;
+        BYTE            bSectorType;
+        BOOL            UseForOperation;
+        BOOL        UseForErase;
+        BOOL        UseForUpload;
+        BOOL        UseForWriteProtect;
+} MAPPINGSECTOR, *PMAPPINGSECTOR;
+typedef struct {
+        BYTE                    nAlternate;
+        char                    Name[MAX_PATH];
+        DWORD                   NbSectors;
+        PMAPPINGSECTOR  pSectors;
+} MAPPING, *PMAPPING;
+typedef struct {
+        DWORD           dwAddress;
+        DWORD           dwDataLength;
+        PBYTE           Data;
+} IMAGEELEMENT, *PIMAGEELEMENT;
+#endif
+/******************* (C) COPYRIGHT 2009 STMicroelectronics *****END OF FILE******/

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/Files/Image.h
 ,0 → 1,63
+/******************** (C) COPYRIGHT 2009 STMicroelectronics ********************
+* File Name          : Image.h
+* Author             : MCD Application Team
+* Version            : v2.1.0
+* Date               : 11/02/2009
+* Description        : Defines the CImage class interface
+********************************************************************************
+* THE PRESENT SOFTWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
+* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
+* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
+* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
+* CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
+* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+*******************************************************************************/
+#ifndef _IMAGE_H_
+#define _IMAGE_H_
+class CImage : public CObject
+{
+private:
+        char            m_LastError[1000];
+        BYTE            m_bAlternate;
+        CPtrArray       *m_pElements;
+        BOOL            m_ImageState;
+        BOOL            m_bNamed;
+        char            m_Name[255];
+        BOOL            LoadS19(PSTR pFilePath);
+        BOOL            LoadHEX(PSTR pFilePath);
+        BOOL            LoadBIN(PSTR pFilePath);
+        BOOL            SaveS19(PSTR pFilePath);
+        BOOL            SaveHEX(PSTR pFilePath);
+        void            LDisplayError(PSTR Str) { lstrcpy(m_LastError, Str); }
+        BOOL        ExistsElementsAtAddress(DWORD Address);
+        void            CompactElements();
+public:
+        CImage(CImage *pSource);
+        CImage(BYTE bAlternate, BOOL bNamed, PSTR Name);
+        CImage(PMAPPING pMapping, BOOL bNamed, PSTR Name);
+        CImage(BYTE bAlternate, PSTR pFilePath, BOOL bNamed, PSTR Name);
+        virtual ~CImage();
+        BOOL    DumpToFile(PSTR pFilePath);
+        BYTE    GetAlternate() { return m_bAlternate; }
+        BOOL    GetImageState() { return m_ImageState; }
+        BOOL    GetName(PSTR Name) { if (m_bNamed) lstrcpy(Name, m_Name); return m_bNamed; }
+        void    SetName(PSTR Name) { lstrcpy(m_Name, Name); m_bNamed=TRUE; }
+        BOOL    GetBuffer(DWORD dwAddress, DWORD dwSize, PBYTE pBuffer);
+        DWORD   GetNbElements() { return m_pElements->GetSize(); }
+        BOOL    SetImageElement(DWORD dwRank, BOOL bInsert, IMAGEELEMENT Element);
+        BOOL    GetImageElement(DWORD dwRank, PIMAGEELEMENT pElement);
+        BOOL    FilterImageForOperation(PMAPPING pMapping, DWORD Operation, BOOL bTruncateLeadFF);
+        BOOL    DestroyImageElement(DWORD dwRank);
+};
+#endif
+/******************* (C) COPYRIGHT 2009 STMicroelectronics *****END OF FILE******/

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/Files/Release/Files.lib
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/Files/res/Files.rc2
 ,0 → 1,13
+//
+// FILES.RC2 - resources Microsoft Visual C++ does not edit directly
+//
+#ifdef APSTUDIO_INVOKED
+        #error this file is not editable by Microsoft Visual C++
+#endif //APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+// Add manually edited resources here...
+/////////////////////////////////////////////////////////////////////////////

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/Files/resource.h
 ,0 → 1,15
+//{{NO_DEPENDENCIES}}
+// Microsoft Developer Studio generated include file.
+// Used by Files.rc
+//
+// Next default values for new objects
+//
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        101
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1000
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STBLLIB/Debug/STBLLIB.exp
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STBLLIB/Debug/STBLLIB.lib
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STBLLIB/Debug/STBLLIB.obj
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STBLLIB/Debug/STBLLIB.pdb
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STBLLIB/Debug/STBLLIB.res
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STBLLIB/Debug/STBLLIB.sbr
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STBLLIB/Debug/rs232.obj
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STBLLIB/Debug/rs232.sbr
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STBLLIB/Debug/vc60.idb
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STBLLIB/Debug/vc60.pdb
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STBLLIB/Release/STBLLIB.exp
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STBLLIB/Release/STBLLIB.lib
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STBLLIB/Release/STBLLIB.obj
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STBLLIB/Release/STBLLIB.res
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STBLLIB/Release/rs232.obj
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STBLLIB/Release/vc60.idb
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STBLLIB/STBLLIB.cpp
 ,0 → 1,827
+/******************** (C) COPYRIGHT 2010 STMicroelectronics ********************
+* File Name          : STBLLIB.cpp
+* Author             : MCD Application Team
+* Version            : v2.2.0
+* Date               : 05/03/2010
+* Description        : Implements the System memory boot loader protocol interface
+********************************************************************************
+* THE PRESENT SOFTWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
+* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
+* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
+* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
+* CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
+* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+*******************************************************************************/
+#include <malloc.h>
+#include "stdafx.h"
+#include "STBLLIB.h"
+/************************************************************************************/
+/* Generic BL API types
+/*
+/*
+/************************************************************************************/
+typedef BYTE virt_GetProgress(LPBYTE progress);
+typedef BYTE virt_GetActivityTime(LPDWORD time);
+typedef BYTE virt_SetActivityTime(DWORD time);
+typedef BYTE virt_TARGET_GetFlashSize(DWORD Addr, LPWORD val);
+typedef BYTE virt_TARGET_GetMemoryAddress(DWORD Addr, LPBYTE val);
+typedef BYTE virt_TARGET_GetRDPOptionByte(LPBYTE RDP);
+typedef BYTE virt_TARGET_GetWRPOptionBytes(LPBYTE WRP0, LPBYTE WRP1, LPBYTE WRP2, LPBYTE WRP3);
+typedef BYTE virt_Send_RQ(LPSTBL_Request pRQ);
+typedef BYTE virt_SetCOMSettings(int numPort, long speedInBaud, int nbBit, int parity, float nbStopBit);
+typedef BYTE virt_COM_Open();
+typedef BYTE virt_COM_Close();
+typedef BYTE virt_STBL_SetSpeed(DWORD speed);
+typedef BYTE virt_STBL_Init_BL();
+typedef BYTE virt_STBL_GET(LPBYTE Version, LPCommands pCmds);
+typedef BYTE virt_STBL_GET_VER_ROPS(LPBYTE Version, LPBYTE ROPEnabled, LPBYTE ROPDisabled);
+typedef BYTE virt_STBL_GET_ID(LPBYTE size, LPBYTE pID);
+typedef BYTE virt_STBL_READ(DWORD Address, BYTE Size, LPBYTE pData);
+typedef BYTE virt_STBL_GO(DWORD Address);
+typedef BYTE virt_STBL_WRITE(DWORD address, BYTE size, LPBYTE pData);
+typedef BYTE virt_STBL_ERASE(WORD NbSectors, LPBYTE pSectors);
+typedef BYTE virt_STBL_WRITE_PROTECT(BYTE NbSectors, LPBYTE pSectors);
+typedef BYTE virt_STBL_WRITE_TEMP_UNPROTECT();
+typedef BYTE virt_STBL_WRITE_PERM_UNPROTECT();
+typedef BYTE virt_STBL_READOUT_PROTECT();
+typedef BYTE virt_STBL_READOUT_TEMP_UNPROTECT();
+typedef BYTE virt_STBL_READOUT_PERM_UNPROTECT();
+typedef BYTE virt_STBL_UPLOAD(DWORD Address, LPBYTE pData, DWORD Length);
+typedef BYTE virt_STBL_VERIFY(DWORD Address, LPBYTE pData, DWORD Length,BOOL bTruncateLeadFFForDnLoad);
+typedef BYTE virt_STBL_DNLOAD(DWORD Address, LPBYTE pData, DWORD Length,BOOL bTruncateLeadFFForDnLoad);
+typedef BYTE virt_SetPaketSize(BYTE size);
+typedef BYTE virt_GetPaketSize(LPBYTE size);
+typedef ACKS virt_GetAckValue();
+typedef BOOL virt_COM_is_Open();
+typedef BYTE virt_SetTimeOut(DWORD vms);
+typedef BYTE virt_TARGET_GetUserOptionByte(LPBYTE User);
+typedef BYTE virt_TARGET_GetDataOptionByte(LPBYTE Data0, LPBYTE Data1);
+typedef BYTE virt_TARGET_SetSIFData(BYTE User, BYTE RDP, BYTE Data0, BYTE Data1, BYTE WRP0, BYTE WRP1, BYTE WRP2, BYTE WRP3);
+typedef BYTE virt_TARGET_GetSIFData(LPBYTE User, LPBYTE RDP, LPBYTE Data0, LPBYTE Data1, LPBYTE WRP0, LPBYTE WRP1, LPBYTE WRP2, LPBYTE WRP3);
+typedef BYTE virt_STBL_SetRts(BOOL Val);
+typedef BYTE virt_STBL_SetDtr(BOOL Val);
+typedef BYTE virt_STBL_setTxd(BOOL val);
+typedef BYTE virt_STBL_getCts(BOOL* pval);
+typedef BYTE virt_STBL_getDtr(BOOL* pval);
+typedef BYTE virt_STBL_getRi(BOOL* pval);
+typedef BYTE virt_STBL_getCd(BOOL* pval);
+typedef BYTE virt_STBL_SetEcho(int val);
+typedef BYTE virt_STBL_SetFlowControl(int Val);
+/************************************************************************************/
+/* Generic BL API references
+/*
+/*
+/************************************************************************************/
+virt_GetProgress                                        *pt_GetProgress;                                                //(LPBYTE progress);
+virt_GetActivityTime                            *pt_GetActivityTime;                                    //(LPDWORD time);
+virt_SetActivityTime                            *pt_SetActivityTime;                                    //(DWORD time);
+virt_TARGET_GetFlashSize                        *pt_TARGET_GetFlashSize;                                //(DWORD Addr, LPWORD val);
+virt_TARGET_GetMemoryAddress            *pt_TARGET_GetMemoryAddress;                    //(DWORD Addr, LPWORD val);
+virt_TARGET_GetRDPOptionByte            *pt_TARGET_GetRDPOptionByte;                    //(LPBYTE RDP);
+virt_TARGET_GetWRPOptionBytes           *pt_TARGET_GetWRPOptionBytes;           //(LPBYTE WRP0, LPBYTE WRP1, LPBYTE WRP2, LPBYTE WRP3);
+virt_Send_RQ                                            *pt_Send_RQ;                                                    //(LPSTBL_Request pRQ);
+virt_SetCOMSettings                                     *pt_SetCOMSettings;                                     //(int numPort, long speedInBaud, int nbBit, int parity, float nbStopBit);
+virt_COM_Open                                           *pt_COM_Open;                                           //();
+virt_COM_Close                                          *pt_COM_Close;                                          //();
+virt_STBL_SetSpeed                                      *pt_STBL_SetSpeed;                                      //(DWORD speed);
+virt_STBL_Init_BL                                       *pt_STBL_Init_BL;                                       //();
+virt_STBL_GET                                           *pt_STBL_GET;                                           //(LPBYTE Version, LPCommands pCmds);
+virt_STBL_GET_VER_ROPS                          *pt_STBL_GET_VER_ROPS;                          //(LPBYTE Version, LPBYTE ROPEnabled, LPBYTE ROPDisabled);
+virt_STBL_GET_ID                                        *pt_STBL_GET_ID;                                                //(LPBYTE size, LPBYTE pID);
+virt_STBL_READ                                          *pt_STBL_READ;                                          //(DWORD Address, BYTE Size, LPBYTE pData);
+virt_STBL_GO                                            *pt_STBL_GO;                                                    //(DWORD Address);
+virt_STBL_WRITE                                         *pt_STBL_WRITE;                                         //(DWORD address, BYTE size, LPBYTE pData);
+virt_STBL_ERASE                                         *pt_STBL_ERASE;                                         //(BYTE NbSectors, LPBYTE pSectors);
+virt_STBL_WRITE_PROTECT                         *pt_STBL_WRITE_PROTECT;                         //(BYTE NbSectors, LPBYTE pSectors);
+virt_STBL_WRITE_TEMP_UNPROTECT          *pt_STBL_WRITE_TEMP_UNPROTECT;          //();
+virt_STBL_WRITE_PERM_UNPROTECT          *pt_STBL_WRITE_PERM_UNPROTECT;          //();
+virt_STBL_READOUT_PROTECT                       *pt_STBL_READOUT_PROTECT;                       //();
+virt_STBL_READOUT_TEMP_UNPROTECT        *pt_STBL_READOUT_TEMP_UNPROTECT;                //();
+virt_STBL_READOUT_PERM_UNPROTECT        *pt_STBL_READOUT_PERM_UNPROTECT;                //();
+virt_STBL_UPLOAD                                        *pt_STBL_UPLOAD;                                                //(DWORD Address, LPBYTE pData, DWORD Length);
+virt_STBL_VERIFY                                        *pt_STBL_VERIFY;                                                //(DWORD Address, LPBYTE pData, DWORD Length,BOOL bTruncateLeadFFForDnLoad);
+virt_STBL_DNLOAD                                        *pt_STBL_DNLOAD;                                                //(DWORD Address, LPBYTE pData, DWORD Length,BOOL bTruncateLeadFFForDnLoad);
+virt_SetPaketSize                                       *pt_SetPaketSize;                                       //(BYTE size);
+virt_GetPaketSize                                       *pt_GetPaketSize;                                       //(LPBYTE size);
+virt_GetAckValue                                        *pt_GetAckValue;                                                //();
+virt_COM_is_Open                                        *pt_COM_is_Open;                                                //();
+virt_SetTimeOut                                         *pt_SetTimeOut;                                         //(DWORD vms);
+virt_TARGET_GetUserOptionByte           *pt_TARGET_GetUserOptionByte;           //(LPBYTE User);
+virt_TARGET_GetDataOptionByte           *pt_TARGET_GetDataOptionByte;           //(LPBYTE Data0, LPBYTE Data1);
+virt_TARGET_SetSIFData                          *pt_TARGET_SetSIFData;                          //(BYTE User, BYTE RDP, BYTE Data0, BYTE Data1, BYTE WRP0, BYTE WRP1, BYTE WRP2, BYTE WRP3);
+virt_TARGET_GetSIFData                          *pt_TARGET_GetSIFData;                          //(LPBYTE User, LPBYTE RDP, LPBYTE Data0, LPBYTE Data1, LPBYTE WRP0, LPBYTE WRP1, LPBYTE WRP2, LPBYTE WRP3);
+virt_STBL_SetRts                                        *pt_STBL_SetRts;                                                //(BOOL val);
+virt_STBL_SetDtr                                        *pt_STBL_SetDtr;                                                //(BOOL val);
+virt_STBL_setTxd                                        *pt_STBL_setTxd;                                                //(BOOL val);
+virt_STBL_getCts                                        *pt_STBL_getCts;                                                //(BOOL* pval);
+virt_STBL_getDtr                                        *pt_STBL_getDtr;                                                //(BOOL* pval);
+virt_STBL_getRi                                         *pt_STBL_getRi;                                         //(BOOL* pval);
+virt_STBL_getCd                                         *pt_STBL_getCd;                                         //(BOOL* pval);
+virt_STBL_SetEcho                   *pt_STBL_SetEcho ;                  //(int val);
+virt_STBL_SetFlowControl            *pt_STBL_SetFlowControl ;                  //(bool val);
+DWORD   MAX_DATA_SIZE       = 0xFF;   // Packet size(in byte)
+BYTE    ACK                 = 0x79;
+BYTE    NACK                = 0x1F;
+ACKS ACK_VALUE          = ST79;
+LPTARGET_DESCRIPTOR Target;
+CRS232 Cur_COM;
+ACKS   McuTarget;
+DWORD  Progress;
+DWORD  ActivityTime ;
+HINSTANCE ST_BL_Lib_Hdle = NULL;
+BOOL APIENTRY DllMain( HANDLE hModule,
+                       DWORD  ul_reason_for_call,
+                       LPVOID lpReserved
+                                         )
+{
+    switch (ul_reason_for_call)
+        {
+                case DLL_PROCESS_ATTACH :{
+                                                McuTarget = UNDEFINED;
+                                                                    Target = (LPTARGET_DESCRIPTOR)malloc(sizeof(TARGET_DESCRIPTOR));
+                                                                        Target->Version                    = 0x00;
+                                                                        Target->CmdCount                   = 0x00;
+                                                                        Target->PIDLen                     = 0x00;
+                                                                        Target->PID                        = (LPBYTE)malloc(1);
+                                                                        Target->ROPE                       = 0x00;
+                                                                        Target->ROPD                       = 0x00;
+                                                                        Target->GET_CMD                    = FALSE    ; //Get the version and the allowed commands supported by the current version of the boot loader
+                                                                        Target->GET_VER_ROPS_CMD           = FALSE    ; //Get the BL version and the Read Protection status of the NVM
+                                                                        Target->GET_ID_CMD                 = FALSE    ; //Get the chip ID
+                                                                        Target->READ_CMD                   = FALSE    ; //Read up to 256 bytes of memory starting from an address specified by the user
+                                                                        Target->GO_CMD                     = FALSE    ; //Jump to an address specified by the user to execute (a loaded) code
+                                                                        Target->WRITE_CMD                  = FALSE    ; //Write maximum 256 bytes to the RAM or the NVM starting from an address specified by the user
+                                                                        Target->ERASE_CMD                  = FALSE    ; //Erase from one to all the NVM sectors
+                                                                        Target->ERASE_EXT_CMD              = FALSE    ; //Erase from one to all the NVM sectors
+                                                                        Target->WRITE_PROTECT_CMD          = FALSE    ; //Enable the write protection in a permanent way for some sectors
+                                                                        Target->WRITE_TEMP_UNPROTECT_CMD   = FALSE    ; //Disable the write protection in a temporary way for all NVM sectors
+                                                                        Target->WRITE_PERM_UNPROTECT_CMD   = FALSE    ; //Disable the write protection in a permanent way for all NVM sectors
+                                                                        Target->READOUT_PERM_PROTECT_CMD   = FALSE    ; //Enable the readout protection in a permanent way
+                                                                        Target->READOUT_TEMP_UNPROTECT_CMD = FALSE    ; //Disable the readout protection in a temporary way
+                                                                        Target->READOUT_PERM_UNPROTECT_CMD = FALSE    ; //Disable the readout protection in a permanent way
+                                                                 }break;
+                case DLL_THREAD_ATTACH  :{
+                                                /*McuTarget = UNDEFINED;
+                                                                    Target = (LPTARGET_DESCRIPTOR)malloc(sizeof(TARGET_DESCRIPTOR));
+                                                                        Target->Version                    = 0x00;
+                                                                        Target->CmdCount                   = 0x00;
+                                                                        Target->PIDLen                     = 0x00;
+                                                                        Target->PID                        = (LPBYTE)malloc(1);
+                                                                        Target->ROPE                       = 0x00;
+                                                                        Target->ROPD                       = 0x00;
+                                                                        Target->GET_CMD                    = FALSE    ; //Get the version and the allowed commands supported by the current version of the boot loader
+                                                                        Target->GET_VER_ROPS_CMD           = FALSE    ; //Get the BL version and the Read Protection status of the NVM
+                                                                        Target->GET_ID_CMD                 = FALSE    ; //Get the chip ID
+                                                                        Target->READ_CMD                   = FALSE    ; //Read up to 256 bytes of memory starting from an address specified by the user
+                                                                        Target->GO_CMD                     = FALSE    ; //Jump to an address specified by the user to execute (a loaded) code
+                                                                        Target->WRITE_CMD                  = FALSE    ; //Write maximum 256 bytes to the RAM or the NVM starting from an address specified by the user
+                                                                        Target->ERASE_CMD                  = FALSE    ; //Erase from one to all the NVM sectors
+                                                                        Target->WRITE_PROTECT_CMD          = FALSE    ; //Enable the write protection in a permanent way for some sectors
+                                                                        Target->WRITE_TEMP_UNPROTECT_CMD   = FALSE    ; //Disable the write protection in a temporary way for all NVM sectors
+                                                                        Target->WRITE_PERM_UNPROTECT_CMD   = FALSE    ; //Disable the write protection in a permanent way for all NVM sectors
+                                                                        Target->READOUT_PERM_PROTECT_CMD   = FALSE    ; //Enable the readout protection in a permanent way
+                                                                        Target->READOUT_TEMP_UNPROTECT_CMD = FALSE    ; //Disable the readout protection in a temporary way
+                                                                        Target->READOUT_PERM_UNPROTECT_CMD = FALSE    ; //Disable the readout protection in a permanent way
+                                                                 */}break;
+                case DLL_THREAD_DETACH  :{}break;
+                case DLL_PROCESS_DETACH :{}break;
+    }
+    return TRUE;
+}
+/************************************************************************************/
+/* SET COMMUNICATION INTERFACE TYPE
+/* UART - CAN - ...
+/*
+/************************************************************************************/
+STBLLIB_API BYTE TARGET_SetComIntType(BYTE com_int_type)
+{
+        //com_int_type = 0; //  This is reserved for Future, When the CANtoUSB Bridge will be available
+                          //  The CAN module and DLL should be used in com_int_type =1
+        switch (com_int_type)
+        {
+                case 0:{
+                                        ST_BL_Lib_Hdle = GetModuleHandle("STUARTBLLIB");
+                                        if ( ST_BL_Lib_Hdle == NULL )
+                                        {
+                                                ST_BL_Lib_Hdle = LoadLibrary("STUARTBLLIB") ;
+                                        }
+                   }break;
+                case 1:{
+                                        ST_BL_Lib_Hdle = GetModuleHandle("STCANBLLIB");
+                                        if ( ST_BL_Lib_Hdle == NULL )
+                                        {
+                                                ST_BL_Lib_Hdle = LoadLibrary("STCANBLLIB") ;
+                                        }
+                   }break;
+        }
+        pt_GetProgress                                  = (virt_GetProgress*)GetProcAddress(ST_BL_Lib_Hdle,"GetProgress");
+        pt_GetActivityTime                              = (virt_GetActivityTime*)GetProcAddress(ST_BL_Lib_Hdle,"GetActivityTime");                      //(LPDWORD time);
+        pt_SetActivityTime                              = (virt_SetActivityTime*)GetProcAddress(ST_BL_Lib_Hdle,"SetActivityTime");                              //(DWORD time);
+        pt_TARGET_GetFlashSize                  = (virt_TARGET_GetFlashSize*)GetProcAddress(ST_BL_Lib_Hdle,"TARGET_GetFlashSize");
+        pt_TARGET_GetMemoryAddress              = (virt_TARGET_GetMemoryAddress*)GetProcAddress(ST_BL_Lib_Hdle,"TARGET_GetMemoryAddress");
+        pt_TARGET_GetRDPOptionByte              = (virt_TARGET_GetRDPOptionByte*)GetProcAddress(ST_BL_Lib_Hdle,"TARGET_GetRDPOptionByte");
+        pt_TARGET_GetWRPOptionBytes             = (virt_TARGET_GetWRPOptionBytes*)GetProcAddress(ST_BL_Lib_Hdle,"TARGET_GetWRPOptionBytes");
+        pt_Send_RQ                                              = (virt_Send_RQ*)GetProcAddress(ST_BL_Lib_Hdle,"Send_RQ");
+        pt_SetCOMSettings                               = (virt_SetCOMSettings*)GetProcAddress(ST_BL_Lib_Hdle,"SetCOMSettings");
+        pt_COM_Open                                             = (virt_COM_Open*)GetProcAddress(ST_BL_Lib_Hdle,"COM_Open");
+        pt_COM_Close                                    = (virt_COM_Close*)GetProcAddress(ST_BL_Lib_Hdle,"COM_Close");
+        pt_STBL_SetSpeed                                = (virt_STBL_SetSpeed*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_SetSpeed");
+        pt_STBL_Init_BL                                 = (virt_STBL_Init_BL*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_Init_BL");
+        pt_STBL_GET                                             = (virt_STBL_GET*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_GET");
+        pt_STBL_GET_VER_ROPS                    = (virt_STBL_GET_VER_ROPS*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_GET_VER_ROPS");
+        pt_STBL_GET_ID                                  = (virt_STBL_GET_ID*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_GET_ID");
+        pt_STBL_READ                                    = (virt_STBL_READ*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_READ");
+        pt_STBL_GO                                              = (virt_STBL_GO*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_GO");
+        pt_STBL_WRITE                                   = (virt_STBL_WRITE*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_WRITE");
+        pt_STBL_ERASE                                   = (virt_STBL_ERASE*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_ERASE");
+        pt_STBL_WRITE_PROTECT                   = (virt_STBL_WRITE_PROTECT*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_WRITE_PROTECT");
+        pt_STBL_WRITE_TEMP_UNPROTECT    = (virt_STBL_WRITE_TEMP_UNPROTECT*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_WRITE_TEMP_UNPROTECT");
+        pt_STBL_WRITE_PERM_UNPROTECT    = (virt_STBL_WRITE_PERM_UNPROTECT*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_WRITE_PERM_UNPROTECT");
+        pt_STBL_READOUT_PROTECT                 = (virt_STBL_READOUT_PROTECT*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_READOUT_PROTECT");
+        pt_STBL_READOUT_TEMP_UNPROTECT  = (virt_STBL_READOUT_TEMP_UNPROTECT*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_READOUT_TEMP_UNPROTECT");
+        pt_STBL_READOUT_PERM_UNPROTECT  = (virt_STBL_READOUT_PERM_UNPROTECT*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_READOUT_PERM_UNPROTECT");
+        pt_STBL_UPLOAD                                  = (virt_STBL_UPLOAD*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_UPLOAD");
+        pt_STBL_VERIFY                                  = (virt_STBL_VERIFY*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_VERIFY");
+        pt_STBL_DNLOAD                                  = (virt_STBL_DNLOAD*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_DNLOAD");
+        pt_SetPaketSize                                 = (virt_SetPaketSize*)GetProcAddress(ST_BL_Lib_Hdle,"SetPaketSize");
+        pt_GetPaketSize                                 = (virt_GetPaketSize*)GetProcAddress(ST_BL_Lib_Hdle,"GetPaketSize");
+        pt_GetAckValue                                  = (virt_GetAckValue*)GetProcAddress(ST_BL_Lib_Hdle,"GetAckValue");
+        pt_COM_is_Open                                  = (virt_COM_is_Open*)GetProcAddress(ST_BL_Lib_Hdle,"COM_is_Open");
+        pt_SetTimeOut                                   = (virt_SetTimeOut*)GetProcAddress(ST_BL_Lib_Hdle,"SetTimeOut");
+        pt_TARGET_GetUserOptionByte             = (virt_TARGET_GetUserOptionByte*)GetProcAddress(ST_BL_Lib_Hdle,"TARGET_GetUserOptionByte");
+        pt_TARGET_GetDataOptionByte             = (virt_TARGET_GetDataOptionByte*)GetProcAddress(ST_BL_Lib_Hdle,"TARGET_GetDataOptionByte");
+        pt_TARGET_SetSIFData                    = (virt_TARGET_SetSIFData*)GetProcAddress(ST_BL_Lib_Hdle,"TARGET_SetSIFData");
+        pt_TARGET_GetSIFData                    = (virt_TARGET_GetSIFData*)GetProcAddress(ST_BL_Lib_Hdle,"TARGET_GetSIFData");
+        pt_STBL_SetRts                                  = (virt_STBL_SetRts*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_SetRts");
+        pt_STBL_SetDtr                                  = (virt_STBL_SetDtr*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_SetDtr");
+        pt_STBL_setTxd                                  = (virt_STBL_setTxd*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_setTxd");
+        pt_STBL_getCts                                  = (virt_STBL_getCts*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_getCts");
+        pt_STBL_getDtr                                  = (virt_STBL_getDtr*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_getDtr");
+        pt_STBL_getRi                                   = (virt_STBL_getRi*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_getRi");
+        pt_STBL_getCd                                   = (virt_STBL_getCd*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_getCd");
+    pt_STBL_SetEcho                                     = (virt_STBL_SetEcho*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_SetEcho");
+        pt_STBL_SetFlowControl                  = (virt_STBL_SetFlowControl*)GetProcAddress(ST_BL_Lib_Hdle,"STBL_SetFlowControl");
+        return 0;
+}
+/************************************************************************************/
+/*Set the communication settings for UART, CAN, ...
+/* UART - numPort, speedInBaud, nbBit,  parity, nbStopBit
+/* CAN  - only : speedInBaud
+/************************************************************************************/
+STBLLIB_API BYTE SetCOMSettings(int numPort, long speedInBaud, int nbBit,
+                                    int parity, float nbStopBit)
+{
+        if(pt_SetCOMSettings)
+                return pt_SetCOMSettings(numPort, speedInBaud, nbBit, parity, nbStopBit);
+        else
+                return LIB_LOADING_ERROR;
+}
+STBLLIB_API BYTE Send_RQ(LPSTBL_Request pRQ)
+{
+        if(pt_Send_RQ)
+                return pt_Send_RQ(pRQ);
+        else
+                return LIB_LOADING_ERROR;
+}
+STBLLIB_API BYTE COM_Open()
+{
+        if(pt_COM_Open)
+                return pt_COM_Open();
+        else
+                return LIB_LOADING_ERROR;
+}
+STBLLIB_API BYTE COM_Close()
+{
+        if(pt_COM_Close)
+                return pt_COM_Close();
+        else
+                return LIB_LOADING_ERROR;
+}
+STBLLIB_API BYTE STBL_SetSpeed(DWORD speed)
+{
+        if(pt_STBL_SetSpeed)
+                return pt_STBL_SetSpeed(speed);
+        else
+                return LIB_LOADING_ERROR;
+}
+STBLLIB_API BYTE STBL_Init_BL()
+{
+        if(pt_STBL_Init_BL)
+                return pt_STBL_Init_BL();
+        else
+                return LIB_LOADING_ERROR;
+}
+/******************************************************************************************/
+/* Boot Loader commands implementation
+/******************************************************************************************/
+STBLLIB_API BYTE STBL_GET(LPBYTE Version, LPCommands pCmds)
+{
+        if(pt_STBL_GET)
+                return pt_STBL_GET(Version, pCmds);
+        else
+                return LIB_LOADING_ERROR;
+}
+STBLLIB_API BYTE STBL_GET_VER_ROPS(LPBYTE Version, LPBYTE ROPEnabled, LPBYTE ROPDisabled)
+{
+        if(pt_STBL_GET_VER_ROPS)
+                return pt_STBL_GET_VER_ROPS(Version, ROPEnabled, ROPDisabled);
+        else
+                return LIB_LOADING_ERROR;
+}
+STBLLIB_API BYTE STBL_GET_ID(LPBYTE size, LPBYTE pID)
+{
+        if(pt_STBL_GET_ID)
+                return pt_STBL_GET_ID(size, pID);
+        else
+                return LIB_LOADING_ERROR;
+}
+STBLLIB_API BYTE STBL_READ(DWORD Address, BYTE Size, LPBYTE pData)
+{
+        if(pt_STBL_READ)
+                return pt_STBL_READ(Address, Size, pData);
+        else
+                return LIB_LOADING_ERROR;
+}
+STBLLIB_API BYTE STBL_GO(DWORD Address)
+{
+        if(pt_STBL_GO)
+                return pt_STBL_GO(Address);
+        else
+                return LIB_LOADING_ERROR;
+}
+STBLLIB_API BYTE STBL_WRITE(DWORD address, BYTE size, LPBYTE pData)
+{
+        if(pt_STBL_WRITE)
+                return pt_STBL_WRITE(address, size, pData);
+        else
+                return LIB_LOADING_ERROR;
+}
+STBLLIB_API BYTE STBL_ERASE(WORD NbSectors, LPBYTE pSectors)
+{
+        if(pt_STBL_ERASE)
+                return pt_STBL_ERASE(NbSectors, pSectors);
+        else
+                return LIB_LOADING_ERROR;
+}
+STBLLIB_API BYTE STBL_WRITE_PROTECT(BYTE NbSectors, LPBYTE pSectors)
+{
+        if(pt_STBL_WRITE_PROTECT)
+                return pt_STBL_WRITE_PROTECT(NbSectors, pSectors);
+        else
+                return LIB_LOADING_ERROR;
+}
+STBLLIB_API BYTE STBL_WRITE_TEMP_UNPROTECT()
+{
+        if(pt_STBL_WRITE_TEMP_UNPROTECT)
+                return pt_STBL_WRITE_TEMP_UNPROTECT();
+        else
+                return LIB_LOADING_ERROR;
+}
+STBLLIB_API BYTE STBL_WRITE_PERM_UNPROTECT()
+{
+        if(pt_STBL_WRITE_PERM_UNPROTECT)
+                return pt_STBL_WRITE_PERM_UNPROTECT();
+        else
+                return LIB_LOADING_ERROR;
+}
+STBLLIB_API BYTE STBL_READOUT_PROTECT()
+{
+        if(pt_STBL_READOUT_PROTECT)
+                return pt_STBL_READOUT_PROTECT();
+        else
+                return LIB_LOADING_ERROR;
+}
+STBLLIB_API BYTE STBL_READOUT_TEMP_UNPROTECT()
+{
+        if(pt_STBL_READOUT_TEMP_UNPROTECT)
+                return pt_STBL_READOUT_TEMP_UNPROTECT();
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/* READOUT_PERM_UNPROTECT
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE STBL_READOUT_PERM_UNPROTECT()
+{
+    if(pt_STBL_READOUT_PERM_UNPROTECT)
+                return pt_STBL_READOUT_PERM_UNPROTECT();
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/* UPLOAD
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE STBL_UPLOAD(DWORD Address, LPBYTE pData, DWORD Length)
+{
+        if(pt_STBL_UPLOAD)
+                return pt_STBL_UPLOAD(Address, pData, Length);
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/* VERIFY
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE STBL_VERIFY(DWORD Address, LPBYTE pData, DWORD Length,BOOL bTruncateLeadFFForDnLoad)
+{
+        if(pt_STBL_VERIFY)
+                return pt_STBL_VERIFY(Address, pData, Length,bTruncateLeadFFForDnLoad);
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/* DNLOAD - this command uses the STBL_WRITE function to download a big block of data
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE STBL_DNLOAD(DWORD Address, LPBYTE pData, DWORD Length,BOOL bTruncateLeadFFForDnLoad)
+{
+        if(pt_STBL_DNLOAD)
+                return pt_STBL_DNLOAD(Address, pData, Length,bTruncateLeadFFForDnLoad);
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/* SET PACKET SIZE
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE SetPaketSize(BYTE size)
+{
+        if(pt_SetPaketSize)
+                return pt_SetPaketSize(size);
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/* GET PACKET SIZE
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE GetPaketSize(LPBYTE size)
+{
+        if(pt_GetPaketSize)
+                return pt_GetPaketSize(size);
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/* GetAckValue
+/*
+/*
+/************************************************************************************/
+STBLLIB_API ACKS GetAckValue()
+{
+        if(pt_GetAckValue)
+                return pt_GetAckValue();
+        else
+                return UNDEFINED;
+}
+/************************************************************************************/
+/* IsConnected
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BOOL COM_is_Open()
+{
+        if(pt_COM_is_Open)
+                return pt_COM_is_Open();
+        else
+                return FALSE;
+}
+/************************************************************************************/
+/* SetTimeOut
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE SetTimeOut(DWORD vms)
+{
+    if(pt_SetTimeOut)
+                return pt_SetTimeOut(vms);
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/* GetFlashSize
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE TARGET_GetFlashSize(DWORD Addr, LPWORD val)
+{
+        if(pt_TARGET_GetFlashSize)
+                return pt_TARGET_GetFlashSize(Addr, val);
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/* GetMemoryAddress
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE TARGET_GetMemoryAddress(DWORD Addr, LPBYTE val)
+{
+        if(pt_TARGET_GetMemoryAddress)
+                return pt_TARGET_GetMemoryAddress(Addr, val);
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/* GetRDPOptionByte
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE TARGET_GetRDPOptionByte(LPBYTE RDP)
+{
+        if(pt_TARGET_GetRDPOptionByte)
+                return pt_TARGET_GetRDPOptionByte(RDP);
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/* GetWRPOptionBytes
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE TARGET_GetWRPOptionBytes(LPBYTE WRP0, LPBYTE WRP1, LPBYTE WRP2, LPBYTE WRP3)
+{
+        if(pt_TARGET_GetWRPOptionBytes)
+                return pt_TARGET_GetWRPOptionBytes(WRP0, WRP1, WRP2, WRP3);
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/* GetUserOptionByte
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE TARGET_GetUserOptionByte(LPBYTE User)
+{
+        if(pt_TARGET_GetUserOptionByte)
+                return pt_TARGET_GetUserOptionByte(User);
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/* GetDataOptionByte
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE TARGET_GetDataOptionByte(LPBYTE Data0, LPBYTE Data1)
+{
+        if(pt_TARGET_GetDataOptionByte)
+                return pt_TARGET_GetDataOptionByte(Data0, Data1);
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/* SetSIFData
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE TARGET_SetSIFData(BYTE User, BYTE RDP, BYTE Data0, BYTE Data1,
+                                                                   BYTE WRP0, BYTE WRP1, BYTE WRP2, BYTE WRP3)
+{
+        if(pt_TARGET_SetSIFData)
+                return pt_TARGET_SetSIFData(User, RDP, Data0, Data1, WRP0, WRP1, WRP2, WRP3);
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/* SetSIFData
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE TARGET_GetSIFData(LPBYTE User, LPBYTE RDP, LPBYTE Data0, LPBYTE Data1,
+                                                                   LPBYTE WRP0, LPBYTE WRP1, LPBYTE WRP2, LPBYTE WRP3)
+{
+        if(pt_TARGET_GetSIFData)
+                return pt_TARGET_GetSIFData(User, RDP, Data0, Data1, WRP0, WRP1, WRP2, WRP3);
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/* GET PROGRESS STATE
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE GetProgress(LPBYTE progress)
+{
+        if(pt_GetProgress)
+                return pt_GetProgress(progress);
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/* Get activity time
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE GetActivityTime(LPDWORD time)
+{
+        if(pt_GetActivityTime)
+                return pt_GetActivityTime(time);
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/* Set activity time
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE SetActivityTime(DWORD time)
+{
+        if(pt_SetActivityTime)
+                return pt_SetActivityTime(time);
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/*   Set Rts Line State
+/*   High = TRUE
+/*   Low  = FALSE
+/************************************************************************************/
+STBLLIB_API BYTE STBL_SetRts(BOOL Val)
+{
+        if(pt_STBL_SetRts)
+                return pt_STBL_SetRts(Val);
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/*   Set Dtr Line State
+/*   High = TRUE
+/*   Low  = FALSE
+/************************************************************************************/
+STBLLIB_API BYTE STBL_SetDtr(BOOL Val)
+{
+    if(pt_Send_RQ)
+                return pt_STBL_SetDtr(Val);
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/*   Set the state of TXD. Return: true if success.
+/*   High = TRUE
+/*   Low  = FALSE
+/************************************************************************************/
+STBLLIB_API BYTE STBL_setTxd(BOOL val)
+{
+        if(pt_STBL_setTxd)
+                return pt_STBL_setTxd(val);
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/*   Return: The state of CTS.
+/*   High = TRUE
+/*   Low  = FALSE
+/************************************************************************************/
+STBLLIB_API BYTE STBL_getCts(BOOL* pval)
+{
+        if(pt_STBL_getCts)
+                return pt_STBL_getCts(pval);
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/*   Return: The state of DTR.
+/*   High = TRUE
+/*   Low  = FALSE
+/************************************************************************************/
+STBLLIB_API BYTE STBL_getDtr(BOOL* pval)
+{
+        if(pt_STBL_getDtr)
+                return pt_STBL_getDtr(pval);
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/*   Return: The state of RI.
+/*   High = TRUE
+/*   Low  = FALSE
+/************************************************************************************/
+STBLLIB_API BYTE STBL_getRi(BOOL* pval)
+{
+        if(pt_STBL_getRi)
+                return pt_STBL_getRi(pval);
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/*   Return: The state of DTR.
+/*   High = TRUE
+/*   Low  = FALSE
+/************************************************************************************/
+STBLLIB_API BYTE STBL_getCd(BOOL* pval)
+{
+        if(pt_STBL_getCd)
+                return pt_STBL_getCd(pval);
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/* Set Echo back Mode
+/*   0   =  Echo Disabled
+/*   1   =  Echo Back Enabled
+/*   2   =  Listen Echo Enabled
+/************************************************************************************/
+STBLLIB_API BYTE STBL_SetEcho(int val)
+{
+        if(pt_STBL_SetEcho)
+                return pt_STBL_SetEcho(val);
+        else
+                return LIB_LOADING_ERROR;
+}
+/************************************************************************************/
+/* SetFlowControl : Enable/Disable Flow Control of DTR and RTS
+/* FALSE   =   Disabled
+/* TRUE    =   Enabled
+/************************************************************************************/
+STBLLIB_API BYTE STBL_SetFlowControl(bool val)
+{
+        if(pt_STBL_SetFlowControl)
+                return pt_STBL_SetFlowControl(val);
+        else
+                return LIB_LOADING_ERROR;
+}
+/******************* (C) COPYRIGHT 2010 STMicroelectronics *****END OF FILE******/

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STBLLIB/STBLLIB.dsp
 ,0 → 1,129
+# Microsoft Developer Studio Project File - Name="STBLLIB" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+CFG=STBLLIB - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "STBLLIB.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "STBLLIB.mak" CFG="STBLLIB - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "STBLLIB - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "STBLLIB - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""$/PC/ST Generic Boot Loader/SOFTWARE/STxx BL Lib/Lib Tester", ESSAAAAA"
+# PROP Scc_LocalPath "..\stblgui"
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+!IF  "$(CFG)" == "STBLLIB - Win32 Release"
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 1
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "STBLLIB_EXPORTS" /Yu"stdafx.h" /FD /c
+# ADD CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "STBLLIB_EXPORTS" /D "_VS6_USED" /D "_WINDLL" /FD /c
+# SUBTRACT CPP /YX /Yc /Yu
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
+# ADD LINK32 /nologo /dll /machine:I386 /out:"..\BIN\Release\STBLLIB.dll"
+!ELSEIF  "$(CFG)" == "STBLLIB - Win32 Debug"
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 1
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "STBLLIB_EXPORTS" /Yu"stdafx.h" /FD /GZ /c
+# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "STBLLIB_EXPORTS" /D "_WINDLL" /D "_VS6_USED" /FR /FD /GZ /c
+# SUBTRACT CPP /YX /Yc /Yu
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 /nologo /dll /debug /machine:I386 /out:"..\BIN\Debug\STBLLIB.dll" /pdbtype:sept
+!ENDIF
+# Begin Target
+# Name "STBLLIB - Win32 Release"
+# Name "STBLLIB - Win32 Debug"
+# Begin Group "Source Files"
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+SOURCE=..\Crs232\rs232.cpp
+# End Source File
+# Begin Source File
+SOURCE=.\STBLLIB.cpp
+# End Source File
+# Begin Source File
+SOURCE=.\STBLLIB.rc
+# End Source File
+# End Group
+# Begin Group "Header Files"
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+SOURCE=..\Crs232\rs232.h
+# End Source File
+# Begin Source File
+SOURCE=.\STBLLIB.h
+# End Source File
+# Begin Source File
+SOURCE=.\StdAfx.h
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STBLLIB/STBLLIB.h
 ,0 → 1,486
+/******************** (C) COPYRIGHT 2010 STMicroelectronics ********************
+* File Name          : STBLLIB.h
+* Author             : MCD Application Team
+* Version            : v2.2.0
+* Date               : 05/03/2010
+* Description        : Defines the system memory boot loader protocol interface
+********************************************************************************
+* THE PRESENT SOFTWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
+* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
+* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
+* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
+* CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
+* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+*******************************************************************************/
+#ifndef STDLIB_H
+#define STDLIB_H
+#include "StdAfx.h"
+#include "../CRs232/rs232.h"
+#ifdef STBLLIB_EXPORTS
+#define STBLLIB_API __declspec(dllexport)
+#else
+#define STBLLIB_API __declspec(dllimport)
+#endif
+const BYTE INIT_CON                    = 0x7F;
+const BYTE GET_CMD                     = 0x00; //Get the version and the allowed commands supported by the current version of the boot loader
+const BYTE GET_VER_ROPS_CMD            = 0x01; //Get the BL version and the Read Protection status of the NVM
+const BYTE GET_ID_CMD                  = 0x02; //Get the chip ID
+const BYTE SET_SPEED_CMD               = 0x03; //set the new baudrate
+const BYTE READ_CMD                    = 0x11; //Read up to 256 bytes of memory starting from an address specified by the user
+const BYTE GO_CMD                      = 0x21; //Jump to an address specified by the user to execute (a loaded) code
+const BYTE WRITE_CMD                   = 0x31; //Write maximum 256 bytes to the RAM or the NVM starting from an address specified by the user
+const BYTE ERASE_CMD                   = 0x43; //Erase from one to all the NVM sectors
+const BYTE ERASE_EXT_CMD               = 0x44; //Erase from one to all the NVM sectors
+const BYTE WRITE_PROTECT_CMD           = 0x63; //Enable the write protection in a permanent way for some sectors
+const BYTE WRITE_TEMP_UNPROTECT_CMD    = 0x71; //Disable the write protection in a temporary way for all NVM sectors
+const BYTE WRITE_PERM_UNPROTECT_CMD    = 0x73; //Disable the write protection in a permanent way for all NVM sectors
+const BYTE READOUT_PROTECT_CMD         = 0x82; //Enable the readout protection in a permanent way
+const BYTE READOUT_TEMP_UNPROTECT_CMD  = 0x91; //Disable the readout protection in a temporary way
+const BYTE READOUT_PERM_UNPROTECT_CMD  = 0x92; //Disable the readout protection in a permanent way
+const BYTE SUCCESS                     = 0x00; // No error
+const BYTE ERROR_OFFSET                = 0x00; //error offset
+const BYTE COM_ERROR_OFFSET            = ERROR_OFFSET + 0x00;
+const BYTE NO_CON_AVAILABLE            = COM_ERROR_OFFSET + 0x01;  // No serial port opened
+const BYTE COM_ALREADY_OPENED          = COM_ERROR_OFFSET + 0x02;  // Serial port already opened
+const BYTE CANT_OPEN_COM               = COM_ERROR_OFFSET + 0x03;  // Fail to open serial port
+const BYTE SEND_FAIL                   = COM_ERROR_OFFSET + 0x04;  // send over serial port fail
+const BYTE READ_FAIL                   = COM_ERROR_OFFSET + 0x05;  // Read from serial port fail
+const BYTE SYS_MEM_ERROR_OFFSET        = ERROR_OFFSET + 0x10;
+const BYTE CANT_INIT_BL                = SYS_MEM_ERROR_OFFSET + 0x01; // Fail to start system memory BL
+const BYTE UNREOGNIZED_DEVICE          = SYS_MEM_ERROR_OFFSET + 0x02; // Unreconized device
+const BYTE CMD_NOT_ALLOWED             = SYS_MEM_ERROR_OFFSET + 0x03; // Command not allowed
+const BYTE CMD_FAIL                    = SYS_MEM_ERROR_OFFSET + 0x04; // command failed
+const BYTE PROGRAM_ERROR_OFFSET        = ERROR_OFFSET + 0x20;
+const BYTE INPUT_PARAMS_ERROR          = PROGRAM_ERROR_OFFSET + 0x01;
+const BYTE INPUT_PARAMS_MEMORY_ALLOCATION_ERROR = PROGRAM_ERROR_OFFSET + 0x02;
+const BYTE LIB_LOADING_ERROR           = PROGRAM_ERROR_OFFSET + 0x03;
+enum  ACKS {UNDEFINED=0x00, ST75=0x75, ST79=0x79};
+enum  INTERFACE_TYPE {UART, CAN};
+enum  EBaudRate { brCustom,br110, br300, br600, br1200, br2400, br4800, br9600, br14400, br19200, br38400,
+                  br56000, br57600, br115200, br128000, br256000 };// Port Numbers ( custom or COM1..COM16 }
+enum  EPortNumber { pnCustom,pnCOM1, pnCOM2, pnCOM3, pnCOM4, pnCOM5, pnCOM6, pnCOM7,pnCOM8, pnCOM9, pnCOM10,
+                    pnCOM11, pnCOM12, pnCOM13,pnCOM14, pnCOM15, pnCOM16 };// Data bits ( 5, 6, 7, 8 }
+enum  EDataBits { db5BITS, db6BITS, db7BITS, db8BITS };
+// Stop bits ( 1, 1.5, 2 }
+enum  EStopBits { sb1BITS, sb1HALFBITS, sb2BITS };
+// Parity ( None, odd, even, mark, space }
+enum  EParity { ptNONE, ptODD, ptEVEN, ptMARK, ptSPACE };
+// Hardware Flow Control ( None, None + RTS always on, RTS/CTS }
+enum  EHwFlowControl { hfNONE, hfNONERTSON, hfRTSCTS };
+// Software Flow Control ( None, XON/XOFF }
+enum  ESwFlowControl { sfNONE, sfXONXOFF };
+// What to do with incomplete (incoming} packets ( Discard, Pass }
+enum  EPacketMode { pmDiscard, pmPass };
+enum  OPERATION {NONE, ERASE, UPLOAD, DNLOAD, DIS_R_PROT, DIS_W_PROT, ENA_R_PROT, ENA_W_PROT};
+typedef struct RESULT
+{
+        OPERATION operation;
+        char*     filename;
+    HANDLE    Image;
+}* LPRESULT;
+typedef struct Commands
+{
+        BOOL GET_CMD                    ; //Get the version and the allowed commands supported by the current version of the boot loader
+    BOOL GET_VER_ROPS_CMD           ; //Get the BL version and the Read Protection status of the NVM
+    BOOL GET_ID_CMD                 ; //Get the chip ID
+        BOOL SET_SPEED_CMD                   ; //Change the CAN baudrate
+    BOOL READ_CMD                   ; //Read up to 256 bytes of memory starting from an address specified by the user
+    BOOL GO_CMD                     ; //Jump to an address specified by the user to execute (a loaded) code
+    BOOL WRITE_CMD                  ; //Write maximum 256 bytes to the RAM or the NVM starting from an address specified by the user
+    BOOL ERASE_CMD                  ; //Erase from one to all the NVM sectors
+    BOOL ERASE_EXT_CMD              ; //Erase from one to all the NVM sectors
+        BOOL WRITE_PROTECT_CMD          ; //Enable the write protection in a permanent way for some sectors
+    BOOL WRITE_TEMP_UNPROTECT_CMD   ; //Disable the write protection in a temporary way for all NVM sectors
+    BOOL WRITE_PERM_UNPROTECT_CMD   ; //Disable the write protection in a permanent way for all NVM sectors
+    BOOL READOUT_PROTECT_CMD   ; //Enable the readout protection in a permanent way
+    BOOL READOUT_TEMP_UNPROTECT_CMD ; //Disable the readout protection in a temporary way
+    BOOL READOUT_PERM_UNPROTECT_CMD ; //Disable the readout protection in a permanent way
+}* LPCommands;
+typedef struct TARGET_DESCRIPTOR
+{
+        BYTE Version                    ;
+        BYTE CmdCount                   ;
+        BYTE PIDLen                     ;
+        BYTE* PID                       ;
+        BYTE ROPE                       ;
+        BYTE ROPD                       ;
+        BOOL GET_CMD                    ; //Get the version and the allowed commands supported by the current version of the boot loader
+    BOOL GET_VER_ROPS_CMD           ; //Get the BL version and the Read Protection status of the NVM
+    BOOL GET_ID_CMD                 ; //Get the chip ID
+    BOOL SET_SPEED_CMD              ;
+        BOOL READ_CMD                   ; //Read up to 256 bytes of memory starting from an address specified by the user
+    BOOL GO_CMD                     ; //Jump to an address specified by the user to execute (a loaded) code
+    BOOL WRITE_CMD                  ; //Write maximum 256 bytes to the RAM or the NVM starting from an address specified by the user
+    BOOL ERASE_CMD                  ; //Erase from one to all the NVM sectors
+        BOOL ERASE_EXT_CMD                  ; //Erase from one to all the NVM sectors
+    BOOL WRITE_PROTECT_CMD          ; //Enable the write protection in a permanent way for some sectors
+    BOOL WRITE_TEMP_UNPROTECT_CMD   ; //Disable the write protection in a temporary way for all NVM sectors
+    BOOL WRITE_PERM_UNPROTECT_CMD   ; //Disable the write protection in a permanent way for all NVM sectors
+    BOOL READOUT_PERM_PROTECT_CMD   ; //Enable the readout protection in a permanent way
+    BOOL READOUT_TEMP_UNPROTECT_CMD ; //Disable the readout protection in a temporary way
+    BOOL READOUT_PERM_UNPROTECT_CMD ; //Disable the readout protection in a permanent way
+}* LPTARGET_DESCRIPTOR;
+typedef struct STBL_Request
+{
+        BYTE   _cmd;
+        DWORD  _address;
+        WORD   _length;
+        BYTE   _nbSectors;
+    LPTARGET_DESCRIPTOR _target;
+        LPBYTE _data;
+        WORD   _wbSectors;
+}* LPSTBL_Request;
+extern "C"
+{
+/************************************************************************************/
+/* GET PROGRESS STATE
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE GetProgress(LPBYTE progress);
+/************************************************************************************/
+/* GET ACTIVITY TIME
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE GetActivityTime(LPDWORD time);
+/************************************************************************************/
+/* SET ACTIVITY TIME
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE SetActivityTime(DWORD time);
+/************************************************************************************/
+/* SET COMMUNICATION INTERFACE TYPE
+/* UART - CAN - ...
+/*
+/************************************************************************************/
+STBLLIB_API BYTE TARGET_SetComIntType(BYTE com_int_type);
+/************************************************************************************/
+/* GetFlashSize
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE TARGET_GetFlashSize(DWORD Addr, LPWORD val);
+/************************************************************************************/
+/* GetMemoryAddress
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE TARGET_GetMemoryAddress(DWORD Addr, LPBYTE val);
+/************************************************************************************/
+/* GetRDPOptionByte
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE TARGET_GetRDPOptionByte(LPBYTE RDP);
+/************************************************************************************/
+/* GetWRPOptionBytes
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE TARGET_GetWRPOptionBytes(LPBYTE WRP0, LPBYTE WRP1, LPBYTE WRP2, LPBYTE WRP3);
+/************************************************************************************/
+/* Basic function to send a request
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE Send_RQ(LPSTBL_Request pRQ);
+/************************************************************************************/
+/*
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE SetCOMSettings(int numPort, long speedInBaud, int nbBit,
+                                    int parity, float nbStopBit);
+/************************************************************************************/
+/*
+/*
+/*
+/************************************************************************************/
+/*STBLLIB_API BYTE ESetCOMSettings(EPortNumber numPort, EBaudRate speedInBaud, EDataBits nbBit,
+                                    EParity parity, EStopBits nbStopBit);*/
+/************************************************************************************/
+/*
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE COM_Open();
+/************************************************************************************/
+/*
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE COM_Close();
+/************************************************************************************/
+/*
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE STBL_SetSpeed(DWORD speed);
+/************************************************************************************/
+/*
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE STBL_Init_BL();
+/************************************************************************************/
+/* 0x00; //Get the version and the allowed commands supported by the current version of the boot loader
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE STBL_GET(LPBYTE Version, LPCommands pCmds);
+/************************************************************************************/
+/* 0x01; //Get the BL version and the Read Protection status of the NVM
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE STBL_GET_VER_ROPS(LPBYTE Version, LPBYTE ROPEnabled, LPBYTE ROPDisabled);
+/************************************************************************************/
+/* 0x02; //Get the chip ID
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE STBL_GET_ID(LPBYTE size, LPBYTE pID);
+/************************************************************************************/
+/* 0x11; //Read up to 256 bytes of memory starting from an address specified by the user
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE STBL_READ(DWORD Address, BYTE Size, LPBYTE pData);
+/************************************************************************************/
+/* 0x21; //Jump to an address specified by the user to execute (a loaded) code
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE STBL_GO(DWORD Address);
+/************************************************************************************/
+/* 0x31; //Write maximum 256 bytes to the RAM or the NVM starting from an address specified by the user
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE STBL_WRITE(DWORD address, BYTE size, LPBYTE pData);
+/************************************************************************************/
+/* 0x43; //Erase from one to all the NVM sectors
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE STBL_ERASE(WORD NbSectors, LPBYTE pSectors);
+/************************************************************************************/
+/* 0x63; //Enable the write protection in a permanent way for some sectors
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE STBL_WRITE_PROTECT(BYTE NbSectors, LPBYTE pSectors);
+/************************************************************************************/
+/* 0x71; //Disable the write protection in a temporary way for all NVM sectors
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE STBL_WRITE_TEMP_UNPROTECT();
+/************************************************************************************/
+/* 0x73; //Disable the write protection in a permanent way for all NVM sectors
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE STBL_WRITE_PERM_UNPROTECT();
+/************************************************************************************/
+/* 0x82; //Enable the readout protection in a permanent way
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE STBL_READOUT_PROTECT();
+/************************************************************************************/
+/* 0x91; //Disable the readout protection in a temporary way
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE STBL_READOUT_TEMP_UNPROTECT();
+/************************************************************************************/
+/* 0x92; //Disable the readout protection in a permanent way
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE STBL_READOUT_PERM_UNPROTECT();
+/************************************************************************************/
+/* UPLOAD
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE STBL_UPLOAD(DWORD Address, LPBYTE pData, DWORD Length);
+/************************************************************************************/
+/* VERIFY
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE STBL_VERIFY(DWORD Address, LPBYTE pData, DWORD Length,BOOL bTruncateLeadFFForDnLoad);
+/************************************************************************************/
+/* DNLOAD
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE STBL_DNLOAD(DWORD Address, LPBYTE pData, DWORD Length,BOOL bTruncateLeadFFForDnLoad);
+/************************************************************************************/
+/* SET PACKET SIZE
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE SetPaketSize(BYTE WORD);
+/************************************************************************************/
+/* GET PACKET SIZE
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE GetPaketSize(LPBYTE size);
+/************************************************************************************/
+/* GetAckValue
+/*
+/*
+/************************************************************************************/
+STBLLIB_API ACKS GetAckValue();
+/************************************************************************************/
+/* IsConnected
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BOOL COM_is_Open();
+/************************************************************************************/
+/* SetTimeOut
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE SetTimeOut(DWORD vms);
+/************************************************************************************/
+/* GetUserOptionByte
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE TARGET_GetUserOptionByte(LPBYTE User);
+/************************************************************************************/
+/* GetDataOptionByte
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE TARGET_GetDataOptionByte(LPBYTE Data0, LPBYTE Data1);
+/************************************************************************************/
+/* SetSIFData
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE TARGET_SetSIFData(BYTE User, BYTE RDP, BYTE Data0, BYTE Data1,
+                                                                   BYTE WRP0, BYTE WRP1, BYTE WRP2, BYTE WRP3);
+/************************************************************************************/
+/* GetSIFData
+/*
+/*
+/************************************************************************************/
+STBLLIB_API BYTE TARGET_GetSIFData(LPBYTE User, LPBYTE RDP, LPBYTE Data0, LPBYTE Data1,
+                                                                   LPBYTE WRP0, LPBYTE WRP1, LPBYTE WRP2, LPBYTE WRP3);
+/************************************************************************************/
+/* Set Rts Line State
+/*   High = TRUE
+/*   Low  = FALSE
+/************************************************************************************/
+STBLLIB_API BYTE STBL_SetRts(BOOL Val);
+/************************************************************************************/
+/* Set Dtr Line State
+/*   High = TRUE
+/*   Low  = FALSE
+/************************************************************************************/
+STBLLIB_API BYTE STBL_SetDtr(BOOL Val);
+/************************************************************************************/
+/*   Set the state of TXD. Return: true if success.
+/*   High = TRUE
+/*   Low  = FALSE
+/************************************************************************************/
+STBLLIB_API BYTE STBL_setTxd(BOOL val);
+/************************************************************************************/
+/*   Return: The state of CTS.
+/*   High = TRUE
+/*   Low  = FALSE
+/************************************************************************************/
+STBLLIB_API BYTE STBL_getCts(BOOL* pval);
+/************************************************************************************/
+/*   Return: The state of DTR.
+/*   High = TRUE
+/*   Low  = FALSE
+/************************************************************************************/
+STBLLIB_API BYTE STBL_getDtr(BOOL* pval);
+/************************************************************************************/
+/*   Return: The state of RI.
+/*   High = TRUE
+/*   Low  = FALSE
+/************************************************************************************/
+STBLLIB_API BYTE STBL_getRi(BOOL* pval);
+/************************************************************************************/
+/*   Return: The state of DTR.
+/*   High = TRUE
+/*   Low  = FALSE
+/************************************************************************************/
+STBLLIB_API BYTE STBL_getCd(BOOL* pval);
+/************************************************************************************/
+/* Set Echo back Mode
+/*   0   =  Echo Disabled
+/*   1   =  Echo Back Enabled
+/*   2   =  Listen Echo Enabled
+/************************************************************************************/
+STBLLIB_API BYTE STBL_SetEcho(int val);
+/************************************************************************************/
+/* SetFlowControl : Enable/Disable Flow Control of DTR and RTS
+/* FALSE   =   Disabled
+/* TRUE    =   Enabled
+/************************************************************************************/
+STBLLIB_API BYTE STBL_SetFlowControl(bool val);
+}
+#endif
+/******************* (C) COPYRIGHT 2010 STMicroelectronics *****END OF FILE******/

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STBLLIB/STBLLIB.plg
 ,0 → 1,31
+<html>
+<body>
+<pre>
+<h1>Build Log</h1>
+<h3>
+--------------------Configuration: STBLLIB - Win32 Debug--------------------
+</h3>
+<h3>Command Lines</h3>
+Creating temporary file "C:\DOCUME~1\Cm\LOCALS~1\Temp\RSP1BF.tmp" with contents
+[
+/nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "STBLLIB_EXPORTS" /D "_WINDLL" /D "_VS6_USED" /FR"Debug/" /Fo"Debug/" /Fd"Debug/" /FD /GZ /c
+"c:\Devel\ARM\Flash Loader Demonstrator\Src\Crs232\rs232.cpp"
+"c:\Devel\ARM\Flash Loader Demonstrator\Src\STBLLIB\STBLLIB.cpp"
+]
+Creating command line "cl.exe @C:\DOCUME~1\Cm\LOCALS~1\Temp\RSP1BF.tmp"
+Creating command line "link.exe /nologo /dll /incremental:yes /pdb:"Debug/STBLLIB.pdb" /debug /machine:I386 /out:"..\BIN\Debug\STBLLIB.dll" /implib:"Debug/STBLLIB.lib" /pdbtype:sept  ".\Debug\rs232.obj" ".\Debug\STBLLIB.obj" ".\Debug\STBLLIB.res" "
+<h3>Output Window</h3>
+Compiling...
+rs232.cpp
+STBLLIB.cpp
+Generating Code...
+Linking...
+   Creating library Debug/STBLLIB.lib and object Debug/STBLLIB.exp
+<h3>Results</h3>
+STBLLIB.dll - 0 error(s), 0 warning(s)
+</pre>
+</body>
+</html>

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STBLLIB/STBLLIB.rc
 ,0 → 1,109
+//Microsoft Developer Studio generated resource script.
+//
+#include "resource.h"
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "afxres.h"
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+#ifndef _MAC
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION 2,2,0,0
+ PRODUCTVERSION 2,2,0,0
+ FILEFLAGSMASK 0x3fL
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x40004L
+ FILETYPE 0x2L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "Comments", "\0"
+            VALUE "CompanyName", "STMicroelectronics\0"
+            VALUE "FileDescription", "Flash Loader protocol Virtual APIs\0"
+            VALUE "FileVersion", "2, 2, 0, 0\0"
+            VALUE "InternalName", "STBLLIB\0"
+            VALUE "LegalCopyright", "Copyright © 2010\0"
+            VALUE "LegalTrademarks", "\0"
+            VALUE "OriginalFilename", "STBLLIB.dll\0"
+            VALUE "PrivateBuild", "\0"
+            VALUE "ProductName", "STMicroelectronics STBLLIB\0"
+            VALUE "ProductVersion", "2, 2, 0, 0\0"
+            VALUE "SpecialBuild", "\0"
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+#endif    // !_MAC
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+TEXTINCLUDE DISCARDABLE
+BEGIN
+    "resource.h\0"
+END
+TEXTINCLUDE DISCARDABLE
+BEGIN
+    "#include ""afxres.h""\r\n"
+    "\0"
+END
+TEXTINCLUDE DISCARDABLE
+BEGIN
+    "\r\n"
+    "\0"
+END
+#endif    // APSTUDIO_INVOKED
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STBLLIB/STBLLIB.vcproj
 ,0 → 1,284
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+        ProjectType="Visual C++"
+        Version="8.00"
+        Name="STBLLIB"
+        ProjectGUID="{F9F56A1E-4355-4CC9-92E9-5815BDC57534}"
+        RootNamespace="STBLLIB"
+        Keyword="MFCProj"
+        >
+        <Platforms>
+                <Platform
+                        Name="Win32"
+                />
+        </Platforms>
+        <ToolFiles>
+        </ToolFiles>
+        <Configurations>
+                <Configuration
+                        Name="Release|Win32"
+                        OutputDirectory=".\Release"
+                        IntermediateDirectory=".\Release"
+                        ConfigurationType="2"
+                        InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC60.vsprops"
+                        UseOfMFC="0"
+                        ATLMinimizesCRunTimeLibraryUsage="false"
+                        CharacterSet="2"
+                        >
+                        <Tool
+                                Name="VCPreBuildEventTool"
+                        />
+                        <Tool
+                                Name="VCCustomBuildTool"
+                        />
+                        <Tool
+                                Name="VCXMLDataGeneratorTool"
+                        />
+                        <Tool
+                                Name="VCWebServiceProxyGeneratorTool"
+                        />
+                        <Tool
+                                Name="VCMIDLTool"
+                                PreprocessorDefinitions="NDEBUG"
+                                MkTypLibCompatible="true"
+                                SuppressStartupBanner="true"
+                                TargetEnvironment="1"
+                                TypeLibraryName=".\Release/STBLLIB.tlb"
+                                HeaderFileName=""
+                        />
+                        <Tool
+                                Name="VCCLCompilerTool"
+                                Optimization="2"
+                                InlineFunctionExpansion="1"
+                                PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;STBLLIB_EXPORTS"
+                                StringPooling="true"
+                                RuntimeLibrary="0"
+                                EnableFunctionLevelLinking="true"
+                                PrecompiledHeaderFile=".\Release/STBLLIB.pch"
+                                AssemblerListingLocation=".\Release/"
+                                ObjectFile=".\Release/"
+                                ProgramDataBaseFileName=".\Release/"
+                                WarningLevel="3"
+                                SuppressStartupBanner="true"
+                        />
+                        <Tool
+                                Name="VCManagedResourceCompilerTool"
+                        />
+                        <Tool
+                                Name="VCResourceCompilerTool"
+                                PreprocessorDefinitions="NDEBUG"
+                                Culture="1033"
+                        />
+                        <Tool
+                                Name="VCPreLinkEventTool"
+                        />
+                        <Tool
+                                Name="VCLinkerTool"
+                                OutputFile="..\BIN\Release\STBLLIB.dll"
+                                LinkIncremental="1"
+                                SuppressStartupBanner="true"
+                                ProgramDatabaseFile=".\Release/STBLLIB.pdb"
+                                ImportLibrary=".\Release/STBLLIB.lib"
+                                TargetMachine="1"
+                        />
+                        <Tool
+                                Name="VCALinkTool"
+                        />
+                        <Tool
+                                Name="VCManifestTool"
+                        />
+                        <Tool
+                                Name="VCXDCMakeTool"
+                        />
+                        <Tool
+                                Name="VCBscMakeTool"
+                                SuppressStartupBanner="true"
+                                OutputFile=".\Release/STBLLIB.bsc"
+                        />
+                        <Tool
+                                Name="VCFxCopTool"
+                        />
+                        <Tool
+                                Name="VCAppVerifierTool"
+                        />
+                        <Tool
+                                Name="VCWebDeploymentTool"
+                        />
+                        <Tool
+                                Name="VCPostBuildEventTool"
+                        />
+                </Configuration>
+                <Configuration
+                        Name="Debug|Win32"
+                        OutputDirectory=".\Debug"
+                        IntermediateDirectory=".\Debug"
+                        ConfigurationType="2"
+                        InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC60.vsprops"
+                        UseOfMFC="1"
+                        ATLMinimizesCRunTimeLibraryUsage="false"
+                        CharacterSet="2"
+                        >
+                        <Tool
+                                Name="VCPreBuildEventTool"
+                        />
+                        <Tool
+                                Name="VCCustomBuildTool"
+                        />
+                        <Tool
+                                Name="VCXMLDataGeneratorTool"
+                        />
+                        <Tool
+                                Name="VCWebServiceProxyGeneratorTool"
+                        />
+                        <Tool
+                                Name="VCMIDLTool"
+                                PreprocessorDefinitions="_DEBUG"
+                                MkTypLibCompatible="true"
+                                SuppressStartupBanner="true"
+                                TargetEnvironment="1"
+                                TypeLibraryName=".\Debug/STBLLIB.tlb"
+                                HeaderFileName=""
+                        />
+                        <Tool
+                                Name="VCCLCompilerTool"
+                                Optimization="0"
+                                PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;STBLLIB_EXPORTS"
+                                MinimalRebuild="true"
+                                BasicRuntimeChecks="3"
+                                RuntimeLibrary="1"
+                                PrecompiledHeaderFile=".\Debug/STBLLIB.pch"
+                                AssemblerListingLocation=".\Debug/"
+                                ObjectFile=".\Debug/"
+                                ProgramDataBaseFileName=".\Debug/"
+                                BrowseInformation="1"
+                                WarningLevel="3"
+                                SuppressStartupBanner="true"
+                                DebugInformationFormat="4"
+                        />
+                        <Tool
+                                Name="VCManagedResourceCompilerTool"
+                        />
+                        <Tool
+                                Name="VCResourceCompilerTool"
+                                PreprocessorDefinitions="_DEBUG"
+                                Culture="1033"
+                        />
+                        <Tool
+                                Name="VCPreLinkEventTool"
+                        />
+                        <Tool
+                                Name="VCLinkerTool"
+                                OutputFile="..\BIN\Debug\STBLLIB.dll"
+                                LinkIncremental="2"
+                                SuppressStartupBanner="true"
+                                GenerateDebugInformation="true"
+                                ProgramDatabaseFile=".\Debug/STBLLIB.pdb"
+                                ImportLibrary=".\Debug/STBLLIB.lib"
+                                TargetMachine="1"
+                        />
+                        <Tool
+                                Name="VCALinkTool"
+                        />
+                        <Tool
+                                Name="VCManifestTool"
+                        />
+                        <Tool
+                                Name="VCXDCMakeTool"
+                        />
+                        <Tool
+                                Name="VCBscMakeTool"
+                                SuppressStartupBanner="true"
+                                OutputFile=".\Debug/STBLLIB.bsc"
+                        />
+                        <Tool
+                                Name="VCFxCopTool"
+                        />
+                        <Tool
+                                Name="VCAppVerifierTool"
+                        />
+                        <Tool
+                                Name="VCWebDeploymentTool"
+                        />
+                        <Tool
+                                Name="VCPostBuildEventTool"
+                        />
+                </Configuration>
+        </Configurations>
+        <References>
+        </References>
+        <Files>
+                <Filter
+                        Name="Source Files"
+                        Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+                        >
+                        <File
+                                RelativePath="..\Crs232\rs232.cpp"
+                                >
+                                <FileConfiguration
+                                        Name="Release|Win32"
+                                        >
+                                        <Tool
+                                                Name="VCCLCompilerTool"
+                                                PreprocessorDefinitions=""
+                                        />
+                                </FileConfiguration>
+                                <FileConfiguration
+                                        Name="Debug|Win32"
+                                        >
+                                        <Tool
+                                                Name="VCCLCompilerTool"
+                                                PreprocessorDefinitions=""
+                                        />
+                                </FileConfiguration>
+                        </File>
+                        <File
+                                RelativePath="STBLLIB.cpp"
+                                >
+                                <FileConfiguration
+                                        Name="Release|Win32"
+                                        >
+                                        <Tool
+                                                Name="VCCLCompilerTool"
+                                                PreprocessorDefinitions=""
+                                        />
+                                </FileConfiguration>
+                                <FileConfiguration
+                                        Name="Debug|Win32"
+                                        >
+                                        <Tool
+                                                Name="VCCLCompilerTool"
+                                                PreprocessorDefinitions=""
+                                        />
+                                </FileConfiguration>
+                        </File>
+                        <File
+                                RelativePath=".\STBLLIB.rc"
+                                >
+                        </File>
+                </Filter>
+                <Filter
+                        Name="Header Files"
+                        Filter="h;hpp;hxx;hm;inl"
+                        >
+                        <File
+                                RelativePath="..\Crs232\rs232.h"
+                                >
+                        </File>
+                        <File
+                                RelativePath="STBLLIB.h"
+                                >
+                        </File>
+                        <File
+                                RelativePath="StdAfx.h"
+                                >
+                        </File>
+                </Filter>
+                <Filter
+                        Name="Resource Files"
+                        Filter="ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+                        >
+                </Filter>
+        </Files>
+        <Globals>
+        </Globals>
+</VisualStudioProject>

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STBLLIB/StdAfx.cpp
 ,0 → 1,10
+// stdafx.cpp : source file that includes just the standard includes
+//      STBLLIB.pch will be the pre-compiled header
+//      stdafx.obj will contain the pre-compiled type information
+#include "stdafx.h"
+// TODO: reference any additional headers you need in STDAFX.H
+// and not in this file

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STBLLIB/StdAfx.h
 ,0 → 1,23
+#if !defined(AFX_STDAFX_H__5756AFC7_1A09_4C0E_B6E8_BA86A975A687__INCLUDED_)
+#define AFX_STDAFX_H__5756AFC7_1A09_4C0E_B6E8_BA86A975A687__INCLUDED_
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+// Insert your headers here
+#define WIN32_LEAN_AND_MEAN             // Exclude rarely-used stuff from Windows headers
+#include <windows.h>
+//#include "../Files/Files.h"
+// TODO: reference additional headers your program requires here
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+#endif // !defined(AFX_STDAFX_H__5756AFC7_1A09_4C0E_B6E8_BA86A975A687__INCLUDED_)

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STBLLIB/resource.h
 ,0 → 1,15
+//{{NO_DEPENDENCIES}}
+// Microsoft Developer Studio generated include file.
+// Used by STBLLIB.rc
+//
+// Next default values for new objects
+//
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        101
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1000
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STMFlashLoader/Files.lib
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STMFlashLoader/Ini.cpp
 ,0 → 1,1064
+/////////////////////////////////////////////////////////////////////////////////
+// Cini Class Implementation
+/////////////////////////////////////////////////////////////////////////////////
+#include "stdafx.h" // include if you got "fatal error C1010: unexpected end of file..."
+#include "Ini.h"
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+#define DEF_PROFILE_NUM_LEN             64 // numeric string length, could be quite long for binary format
+#define DEF_PROFILE_THRESHOLD   512 // temporary string length
+#define DEF_PROFILE_DELIMITER   _T(",") // default string delimiter
+#define DEF_PROFILE_TESTSTRING  _T("{63788286-AE30-4D6B-95DF-3B451C1C79F9}") // Uuid for internal use
+// struct used to be passed to __KeyPairProc as a LPVOID parameter
+struct STR_LIMIT
+{
+        LPTSTR lpTarget;
+        DWORD dwRemain;
+        DWORD dwTotalCopied;
+};
+/////////////////////////////////////////////////////////////////////////////////
+// Constructors & Destructor
+/////////////////////////////////////////////////////////////////////////////////
+CIni::CIni()
+{
+        m_pszPathName = NULL;
+}
+CIni::CIni(LPCTSTR lpPathName)
+{
+        m_pszPathName = NULL;
+        SetPathName(lpPathName);
+}
+CIni::~CIni()
+{
+        if (m_pszPathName != NULL)
+                delete [] m_pszPathName;
+}
+/////////////////////////////////////////////////////////////////////////////////
+// Ini File Path Access
+/////////////////////////////////////////////////////////////////////////////////
+// Assign ini file path name
+void CIni::SetPathName(LPCTSTR lpPathName)
+{
+        if (lpPathName == NULL)
+        {
+                if (m_pszPathName != NULL)
+                        *m_pszPathName = _T('\0');
+        }
+        else
+        {
+                if (m_pszPathName != NULL)
+                        delete [] m_pszPathName;
+                m_pszPathName = _tcsdup(lpPathName);
+        }
+}
+// Retrieve ini file path name
+DWORD CIni::GetPathName(LPTSTR lpBuffer, DWORD dwBufSize) const
+{
+        *lpBuffer = _T('\0');
+        DWORD dwLen = 0;
+        if (lpBuffer != NULL)
+        {
+                _tcsncpy(lpBuffer, m_pszPathName, dwBufSize);
+                dwLen = _tcslen(lpBuffer);
+        }
+        else
+        {
+                // just calculate the required buffer size
+                dwLen = _tcslen(m_pszPathName);
+        }
+        return dwLen;
+}
+#ifdef __AFXWIN_H__
+CString CIni::GetPathName() const
+{
+        return CString(m_pszPathName);
+}
+#endif
+/////////////////////////////////////////////////////////////////////////////////
+// Raw String Access
+/////////////////////////////////////////////////////////////////////////////////
+// Get a profile string value, if the buffer size is not large enough, the result
+// may be truncated.
+DWORD CIni::GetString(LPCTSTR lpSection, LPCTSTR lpKey, LPTSTR lpBuffer, DWORD dwBufSize, LPCTSTR lpDefault) const
+{
+        if (lpBuffer != NULL)
+                *lpBuffer = _T('\0');
+        LPTSTR psz = __GetStringDynamic(lpSection, lpKey, lpDefault);
+        DWORD dwLen = _tcslen(psz);
+        if (lpBuffer != NULL)
+        {
+                _tcsncpy(lpBuffer, psz, dwBufSize);
+                dwLen = min(dwLen, dwBufSize);
+        }
+        delete [] psz;
+        return dwLen;
+}
+#ifdef __AFXWIN_H__
+CString CIni::GetString(LPCTSTR lpSection, LPCTSTR lpKey, LPCTSTR lpDefault) const
+{
+        LPTSTR psz = __GetStringDynamic(lpSection, lpKey, lpDefault);
+        CString str(psz);
+        delete [] psz;
+        return str;
+}
+#endif
+// Write a string value to the ini file
+BOOL CIni::WriteString(LPCTSTR lpSection, LPCTSTR lpKey, LPCTSTR lpValue) const
+{
+        if (lpSection == NULL || lpKey == NULL)
+                return FALSE;
+        return ::WritePrivateProfileString(lpSection, lpKey, lpValue == NULL ? _T("") : lpValue, m_pszPathName);
+}
+// Read a string value from the ini file, append another string after it and then write it
+// back to the ini file
+BOOL CIni::AppendString(LPCTSTR lpSection, LPCTSTR lpKey, LPCTSTR lpString) const
+{
+        if (lpString == NULL)
+                return FALSE;
+        TCHAR* psz = __GetStringDynamic(lpSection, lpKey);
+        TCHAR* pNewString = new TCHAR[_tcslen(psz) + _tcslen(lpString) + 1];
+        _stprintf(pNewString, _T("%s%s"), psz, lpString);
+        const BOOL RES = WriteString(lpSection, lpKey, pNewString);
+        delete [] pNewString;
+        delete [] psz;
+        return RES;
+}
+/////////////////////////////////////////////////////////////////////////////////
+// Ini File String Array Access
+/////////////////////////////////////////////////////////////////////////////////
+// Get an array of string
+DWORD CIni::GetArray(LPCTSTR lpSection, LPCTSTR lpKey, LPTSTR lpBuffer, DWORD dwBufSize, LPCTSTR lpDelimiter, BOOL bTrimString) const
+{
+        if (lpBuffer != NULL)
+                *lpBuffer = _T('\0');
+        if (lpSection == NULL || lpKey == NULL)
+                return 0;
+        LPTSTR psz = __GetStringDynamic(lpSection, lpKey);
+        DWORD dwCopied = 0;
+        if (*psz != _T('\0'))
+        {
+                if (lpBuffer == NULL)
+                {
+                        // just calculate the required buffer size
+                        const DWORD MAX_LEN = _tcslen(psz) + 2;
+                        LPTSTR p = new TCHAR[MAX_LEN + 1];
+                        dwCopied = __StringSplit(psz, p, MAX_LEN, lpDelimiter, bTrimString);
+                        delete [] p;
+                }
+                else
+                {
+                        dwCopied = __StringSplit(psz, lpBuffer, dwBufSize, lpDelimiter, bTrimString);
+                }
+        }
+        delete [] psz;
+        return dwCopied;
+}
+#ifdef __AFXWIN_H__
+void CIni::GetArray(LPCTSTR lpSection, LPCTSTR lpKey, CStringArray *pArray, LPCTSTR lpDelimiter, BOOL bTrimString) const
+{
+        if (pArray != NULL)
+                pArray->RemoveAll();
+        const DWORD LEN = GetArray(lpSection, lpKey, NULL, 0, lpDelimiter);
+        if (LEN == 0)
+                return;
+        LPTSTR psz = new TCHAR[LEN + 3];
+        GetArray(lpSection, lpKey, psz, LEN + 2, lpDelimiter);
+        ParseDNTString(psz, __SubStrAdd, (LPVOID)pArray);
+        delete [] psz;
+}
+#endif
+#ifdef __AFXWIN_H__
+BOOL CIni::WriteArray(LPCTSTR lpSection, LPCTSTR lpKey, const CStringArray *pArray, int nWriteCount, LPCTSTR lpDelimiter) const
+{
+        if (pArray == NULL)
+                return FALSE;
+        if (nWriteCount < 0)
+                nWriteCount = pArray->GetSize();
+        else
+                nWriteCount = min(nWriteCount, pArray->GetSize());
+        const CString DELIMITER = (lpDelimiter == NULL || *lpDelimiter == _T('\0')) ? _T(",") : lpDelimiter;
+        CString sLine;
+        for (int i = 0; i < nWriteCount; i++)
+        {
+                sLine += pArray->GetAt(i);
+                if (i != nWriteCount - 1)
+                        sLine += DELIMITER;
+        }
+        return WriteString(lpSection, lpKey, sLine);
+}
+#endif
+/////////////////////////////////////////////////////////////////////////////////
+// Primitive Data Type Access
+/////////////////////////////////////////////////////////////////////////////////
+// Get a signed integral value
+int CIni::GetInt(LPCTSTR lpSection, LPCTSTR lpKey, int nDefault, int nBase) const
+{
+        TCHAR sz[DEF_PROFILE_NUM_LEN + 1] = _T("");
+        GetString(lpSection, lpKey, sz, DEF_PROFILE_NUM_LEN);
+        return *sz == _T('\0') ? nDefault : int(_tcstoul(sz, NULL, __ValidateBase(nBase)));
+}
+// Get an unsigned integral value
+UINT CIni::GetUInt(LPCTSTR lpSection, LPCTSTR lpKey, UINT nDefault, int nBase) const
+{
+        TCHAR sz[DEF_PROFILE_NUM_LEN + 1] = _T("");
+        GetString(lpSection, lpKey, sz, DEF_PROFILE_NUM_LEN);
+        return *sz == _T('\0') ? nDefault : UINT(_tcstoul(sz, NULL, __ValidateBase(nBase)));
+}
+// Get a boolean value
+BOOL CIni::GetBool(LPCTSTR lpSection, LPCTSTR lpKey, BOOL bDefault) const
+{
+        TCHAR sz[DEF_PROFILE_NUM_LEN + 1] = _T("");
+        GetString(lpSection, lpKey, sz, DEF_PROFILE_NUM_LEN);
+        return StringToBool(sz, bDefault);
+}
+// Get a double floating value
+double CIni::GetDouble(LPCTSTR lpSection, LPCTSTR lpKey, double fDefault) const
+{
+        TCHAR sz[DEF_PROFILE_NUM_LEN + 1] = _T("");
+        GetString(lpSection, lpKey, sz, DEF_PROFILE_NUM_LEN);
+        return *sz == _T('\0') ? fDefault : _tcstod(sz, NULL);
+}
+// Write a signed integral value to the ini file
+BOOL CIni::WriteInt(LPCTSTR lpSection, LPCTSTR lpKey, int nValue, int nBase) const
+{
+        TCHAR szValue[DEF_PROFILE_NUM_LEN + 1] = _T("");
+        __IntToString(nValue, szValue, nBase);
+        return WriteString(lpSection, lpKey, szValue);
+}
+// Write an unsigned value to the ini file
+BOOL CIni::WriteUInt(LPCTSTR lpSection, LPCTSTR lpKey, UINT nValue, int nBase) const
+{
+        TCHAR szValue[DEF_PROFILE_NUM_LEN + 1] = _T("");
+        __UIntToString(nValue, szValue, nBase);
+        return WriteString(lpSection, lpKey, szValue);
+}
+// Write a double floating value to the ini file
+BOOL CIni::WriteDouble(LPCTSTR lpSection, LPCTSTR lpKey, double fValue, int nPrecision) const
+{
+        TCHAR szFmt[16] = _T("%f");
+        if (nPrecision > 0)
+                _stprintf(szFmt, _T("%%.%df"), nPrecision);
+        TCHAR szValue[DEF_PROFILE_NUM_LEN + 1] = _T("");
+        _stprintf(szValue, szFmt, fValue);
+        return WriteString(lpSection, lpKey, szValue);
+}
+// Read a double value from the ini file, increase it then write it back
+BOOL CIni::IncreaseDouble(LPCTSTR lpSection, LPCTSTR lpKey, double fIncrease, int nPrecision) const
+{
+        double f = GetDouble(lpSection, lpKey, 0.0);
+        f += fIncrease;
+        return WriteDouble(lpSection, lpKey, f, nPrecision);
+}
+// Write a boolean value to the ini file
+BOOL CIni::WriteBool(LPCTSTR lpSection, LPCTSTR lpKey, BOOL bValue) const
+{
+        return WriteInt(lpSection, lpKey, bValue ? 1 : 0, BASE_DECIMAL);
+}
+// Read a boolean value from the ini file, invert it(true becomes false, false becomes true),
+// then write it back
+BOOL CIni::InvertBool(LPCTSTR lpSection, LPCTSTR lpKey) const
+{
+        return WriteBool(lpSection, lpKey, !GetBool(lpSection, lpKey, FALSE));
+}
+// Read a int from the ini file, increase it and then write it back to the ini file
+BOOL CIni::IncreaseInt(LPCTSTR lpSection, LPCTSTR lpKey, int nIncrease, int nBase) const
+{
+        int nVal = GetInt(lpSection, lpKey, 0, nBase);
+        nVal += nIncrease;
+        return WriteInt(lpSection, lpKey, nVal, nBase);
+}
+// Read an UINT from the ini file, increase it and then write it back to the ini file
+BOOL CIni::IncreaseUInt(LPCTSTR lpSection, LPCTSTR lpKey, UINT nIncrease, int nBase) const
+{
+        UINT nVal = GetUInt(lpSection, lpKey, 0, nBase);
+        nVal += nIncrease;
+        return WriteUInt(lpSection, lpKey, nVal, nBase);
+}
+TCHAR CIni::GetChar(LPCTSTR lpSection, LPCTSTR lpKey, TCHAR cDefault) const
+{
+        TCHAR sz[2] = _T("");
+        GetString(lpSection, lpKey, sz, 1);
+        return *sz == _T('\0') ? cDefault : sz[0];
+}
+BOOL CIni::WriteChar(LPCTSTR lpSection, LPCTSTR lpKey, TCHAR c) const
+{
+        TCHAR sz[2] = { c, _T('\0') };
+        return WriteString(lpSection, lpKey, sz);
+}
+/////////////////////////////////////////////////////////////////////////////////
+// User-Defined Data Type Access
+/////////////////////////////////////////////////////////////////////////////////
+// Get a block of raw data from the ini file
+DWORD CIni::GetDataBlock(LPCTSTR lpSection, LPCTSTR lpKey, LPVOID lpBuffer, DWORD dwBufSize, DWORD dwOffset) const
+{
+        LPTSTR psz = __GetStringDynamic(lpSection, lpKey);
+        DWORD dwLen = _tcslen(psz) / 2;
+        if (dwLen <= dwOffset)
+        {
+                delete [] psz;
+                return 0;
+        }
+        // verify psz, must be all in hex format
+        for (int i = 0; psz[i] != _T('\0'); i++)
+        {
+                TCHAR c = psz[i];
+                if ((c >= _T('0') && c <= _T('9'))
+                        || (c >= _T('a') && c <= _T('f'))
+                        || (c >= _T('A') && c <= _T('F')))
+                {
+                        // valid
+                }
+                else
+                {
+                        delete [] psz;
+                        return 0;
+                }
+        }
+        DWORD dwProcLen = 0;
+        LPBYTE lpb = (LPBYTE)lpBuffer;
+        if (lpb != NULL)
+        {
+                dwProcLen = min(dwLen - dwOffset, dwBufSize);
+                LPCTSTR p = &psz[dwOffset * 2];
+                for (DWORD i = 0; i < dwProcLen; i++)
+                {
+                        TCHAR sz[3] = _T("");
+                        _tcsncpy(sz, p, 2);
+                        lpb[i] = BYTE(_tcstoul(sz, NULL, 16));
+                        p = &p[2];
+                }
+        }
+        else
+        {
+                dwProcLen = dwLen - dwOffset;
+        }
+        delete [] psz;
+        return dwProcLen;
+}
+// Write a block of raw data to the ini file
+BOOL CIni::WriteDataBlock(LPCTSTR lpSection, LPCTSTR lpKey, LPCVOID lpData, DWORD dwDataSize) const
+{
+        const BYTE* lpb = (const BYTE*)lpData;
+        if (lpb == NULL)
+                return FALSE;
+        LPTSTR psz = new TCHAR[dwDataSize * 2 + 1];
+        for (DWORD i = 0, j = 0; i < dwDataSize; i++, j += 2)
+                _stprintf(&psz[j], _T("%02X"), lpb[i]);
+        const BOOL RES = WriteString(lpSection, lpKey, psz);
+        delete [] psz;
+        return RES;
+}
+// Append a block of raw data to a specified key in the ini file
+BOOL CIni::AppendDataBlock(LPCTSTR lpSection, LPCTSTR lpKey, LPCVOID lpData, DWORD dwDataSize) const
+{
+        const BYTE* lpb = (const BYTE*)lpData;
+        if (lpb == NULL)
+                return FALSE;
+        LPTSTR psz = new TCHAR[dwDataSize * 2 + 1];
+        for (DWORD i = 0, j = 0; i < dwDataSize; i++, j += 2)
+                _stprintf(&psz[j], _T("%02X"), lpb[i]);
+        const BOOL RES = AppendString(lpSection, lpKey, psz);
+        delete [] psz;
+        return RES;
+}
+// Get a POINT value
+POINT CIni::GetPoint(LPCTSTR lpSection, LPCTSTR lpKey, POINT ptDefault) const
+{
+        POINT pt;
+        if (GetDataBlock(lpSection, lpKey, &pt, sizeof(POINT)) != sizeof(POINT))
+                pt = ptDefault;
+        return pt;
+}
+// Get a RECT value
+RECT CIni::GetRect(LPCTSTR lpSection, LPCTSTR lpKey, RECT rcDefault) const
+{
+        RECT rc;
+        if (GetDataBlock(lpSection, lpKey, &rc, sizeof(RECT)) != sizeof(RECT))
+                rc = rcDefault;
+        return rc;
+}
+// Write a POINT to the ini file
+BOOL CIni::WritePoint(LPCTSTR lpSection, LPCTSTR lpKey, POINT pt) const
+{
+        return WriteDataBlock(lpSection, lpKey, &pt, sizeof(POINT));
+}
+// Write a RECT to the ini file
+BOOL CIni::WriteRect(LPCTSTR lpSection, LPCTSTR lpKey, RECT rc) const
+{
+        return WriteDataBlock(lpSection, lpKey, &rc, sizeof(RECT));
+}
+/////////////////////////////////////////////////////////////////////////////////
+// Sections & Keys Access
+/////////////////////////////////////////////////////////////////////////////////
+// Retrieve a list of key-lines(key-pairs) of the specified section
+DWORD CIni::GetKeyLines(LPCTSTR lpSection, LPTSTR lpBuffer, DWORD dwBufSize) const
+{
+        if (lpBuffer != NULL)
+                *lpBuffer = _T('\0');
+        if (lpSection == NULL)
+                return 0;
+        if (lpBuffer == NULL)
+        {
+                // just calculate the required buffer size
+                DWORD dwLen = DEF_PROFILE_THRESHOLD;
+                LPTSTR psz = new TCHAR[dwLen + 1];
+                DWORD dwCopied = ::GetPrivateProfileSection(lpSection, psz, dwLen, m_pszPathName);
+                while (dwCopied + 2 >= dwLen)
+                {
+                        dwLen += DEF_PROFILE_THRESHOLD;
+                        delete [] psz;
+                        psz = new TCHAR[dwLen + 1];
+                        dwCopied = ::GetPrivateProfileSection(lpSection, psz, dwLen, m_pszPathName);
+                }
+                delete [] psz;
+                return dwCopied + 2;
+        }
+        else
+        {
+                return ::GetPrivateProfileSection(lpSection, lpBuffer, dwBufSize, m_pszPathName);
+        }
+}
+// Retrieve a list of key names of the specified section
+DWORD CIni::GetKeyNames(LPCTSTR lpSection, LPTSTR lpBuffer, DWORD dwBufSize) const
+{
+        if (lpBuffer != NULL)
+                *lpBuffer = _T('\0');
+        if (lpSection == NULL)
+                return 0;
+        STR_LIMIT sl;
+        sl.lpTarget = lpBuffer;
+        sl.dwRemain = dwBufSize;
+        sl.dwTotalCopied = 0;
+        const DWORD LEN = GetKeyLines(lpSection, NULL, 0);
+        if (LEN == 0)
+                return 0;
+        LPTSTR psz = new TCHAR[LEN + 1];
+        GetKeyLines(lpSection, psz, LEN);
+        ParseDNTString(psz, __KeyPairProc, (LPVOID)(&sl));
+        delete [] psz;
+        if (lpBuffer != NULL)
+                lpBuffer[sl.dwTotalCopied] = _T('\0');
+        return sl.dwTotalCopied;
+}
+// Get all section names from an ini file
+DWORD CIni::GetSectionNames(LPTSTR lpBuffer, DWORD dwBufSize) const
+{
+        if (lpBuffer == NULL)
+        {
+                // just calculate the required buffer size
+                DWORD dwLen = DEF_PROFILE_THRESHOLD;
+                LPTSTR psz = new TCHAR[dwLen + 1];
+                DWORD dwCopied = ::GetPrivateProfileSectionNames(psz, dwLen, m_pszPathName);
+                while (dwCopied + 2 >= dwLen)
+                {
+                        dwLen += DEF_PROFILE_THRESHOLD;
+                        delete [] psz;
+                        psz = new TCHAR[dwLen + 1];
+                        dwCopied = ::GetPrivateProfileSectionNames(psz, dwLen, m_pszPathName);
+                }
+                delete [] psz;
+                return dwCopied + 2;
+        }
+        else
+        {
+                return ::GetPrivateProfileSectionNames(lpBuffer, dwBufSize, m_pszPathName);
+        }
+}
+#ifdef __AFXWIN_H__
+void CIni::GetSectionNames(CStringArray *pArray) const
+{
+        if (pArray != NULL)
+                pArray->RemoveAll();
+        const DWORD LEN = GetSectionNames(NULL, 0);
+        if (LEN == 0)
+                return;
+        LPTSTR psz = new TCHAR[LEN + 1];
+        GetSectionNames(psz, LEN);
+        ParseDNTString(psz, __SubStrAdd, pArray);
+        delete [] psz;
+}
+#endif
+#ifdef __AFXWIN_H__
+// Retrieve a list of key-lines(key-pairs) of the specified section
+void CIni::GetKeyLines(LPCTSTR lpSection, CStringArray *pArray) const
+{
+        if (pArray != NULL)
+                pArray->RemoveAll();
+        const DWORD LEN = GetKeyLines(lpSection, NULL, 0);
+        if (LEN == 0)
+                return;
+        LPTSTR psz = new TCHAR[LEN + 1];
+        GetKeyLines(lpSection, psz, LEN);
+        ParseDNTString(psz, __SubStrAdd, pArray);
+        delete [] psz;
+}
+#endif
+#ifdef __AFXWIN_H__
+// Retrieve a list of key names of the specified section
+void CIni::GetKeyNames(LPCTSTR lpSection, CStringArray *pArray) const
+{
+        if (pArray == NULL)
+                return;
+        pArray->RemoveAll();
+#ifndef _VS_USED
+        const int LEN = GetKeyNames(lpSection, NULL, 0);
+#else
+        const LEN = GetKeyNames(lpSection, NULL, 0);
+#endif
+        LPTSTR psz = new TCHAR[LEN + 1];
+        GetKeyNames(lpSection, psz, LEN);
+        ParseDNTString(psz, __SubStrAdd, (LPVOID)pArray);
+        delete [] psz;
+}
+#endif
+// Remove whole section from the ini file
+BOOL CIni::DeleteSection(LPCTSTR lpSection) const
+{
+        return ::WritePrivateProfileString(lpSection, NULL, _T(""), m_pszPathName);
+}
+// Remove a key from a section
+BOOL CIni::DeleteKey(LPCTSTR lpSection, LPCTSTR lpKey) const
+{
+        return ::WritePrivateProfileString(lpSection, lpKey, NULL, m_pszPathName);
+}
+BOOL CIni::IsSectionExist(LPCTSTR lpSection) const
+{
+        if (lpSection == NULL)
+                return FALSE;
+        // first get the section name list, then check if lpSection exists
+        // in the list.
+        const DWORD LEN = GetSectionNames(NULL, 0);
+        if (LEN == 0)
+                return FALSE;
+        LPTSTR psz = new TCHAR[LEN + 1];
+        GetSectionNames(psz, LEN);
+        BOOL RES = !ParseDNTString(psz, __SubStrCompare, (LPVOID)lpSection);
+        delete [] psz;
+        return RES;
+}
+BOOL CIni::IsKeyExist(LPCTSTR lpSection, LPCTSTR lpKey) const
+{
+        if (lpSection == NULL || lpKey == NULL)
+                return FALSE;
+        // Test it with the default unique string
+        LPTSTR psz = __GetStringDynamic(lpSection, lpKey, DEF_PROFILE_TESTSTRING);
+        const BOOL RES = (_tcscmp(psz, DEF_PROFILE_TESTSTRING) != 0);
+        delete [] psz;
+        return RES;
+}
+BOOL CIni::CopySection(LPCTSTR lpSrcSection, LPCTSTR lpDestSection, BOOL bFailIfExist) const
+{
+        if (lpSrcSection == NULL || lpDestSection == NULL)
+                return FALSE;
+        if (_tcsicmp(lpSrcSection, lpDestSection) == 0)
+                return FALSE;
+        if (!IsSectionExist(lpSrcSection))
+                return FALSE;
+        if (bFailIfExist && IsSectionExist(lpDestSection))
+                return FALSE;
+        DeleteSection(lpDestSection);
+        const DWORD SRC_LEN = GetKeyLines(lpSrcSection, NULL, 0);
+        LPTSTR psz = new TCHAR[SRC_LEN + 2];
+        //memset(psz, 0, sizeof(TCHAR) * (SRC_LEN + 2));
+        GetKeyLines(lpSrcSection, psz, SRC_LEN);
+        const BOOL RES = ::WritePrivateProfileSection(lpDestSection, psz, m_pszPathName);
+        delete [] psz;
+        return RES;
+}
+BOOL CIni::CopyKey(LPCTSTR lpSrcSection, LPCTSTR lpSrcKey, LPCTSTR lpDestSection, LPCTSTR lpDestKey, BOOL bFailIfExist) const
+{
+        if (lpSrcSection == NULL || lpSrcKey == NULL || lpDestKey == NULL)
+                return FALSE;
+        if (_tcsicmp(lpSrcSection, lpDestSection) == 0
+                && _tcsicmp(lpSrcKey, lpDestKey) == 0)
+                return FALSE;
+        if (!IsKeyExist(lpSrcSection, lpSrcKey))
+                return FALSE;
+        if (bFailIfExist && IsKeyExist(lpDestSection, lpDestKey))
+                return FALSE;
+        LPTSTR psz = __GetStringDynamic(lpSrcSection, lpSrcKey);
+        const BOOL RES = WriteString(lpDestSection, lpDestKey, psz);
+        delete [] psz;
+        return RES;
+}
+BOOL CIni::MoveSection(LPCTSTR lpSrcSection, LPCTSTR lpDestSection, BOOL bFailIfExist) const
+{
+        return CopySection(lpSrcSection, lpDestSection, bFailIfExist)
+                && DeleteSection(lpSrcSection);
+}
+BOOL CIni::MoveKey(LPCTSTR lpSrcSection, LPCTSTR lpSrcKey, LPCTSTR lpDestSection, LPCTSTR lpDestKey, BOOL bFailIfExist) const
+{
+        return CopyKey(lpSrcSection, lpSrcKey, lpDestSection, lpDestKey, bFailIfExist)
+                && DeleteKey(lpSrcSection, lpSrcKey);
+}
+/////////////////////////////////////////////////////////////////////////////////
+// Helper Functions
+/////////////////////////////////////////////////////////////////////////////////
+// Get a profile string value, return a heap pointer so we do not have to worry
+// about the buffer size, however, this function requires the caller to manually
+// free the memory.
+// This function is the back-bone of all "Getxxx" functions of this class.
+LPTSTR CIni::__GetStringDynamic(LPCTSTR lpSection, LPCTSTR lpKey, LPCTSTR lpDefault) const
+{
+        TCHAR* psz = NULL;
+        if (lpSection == NULL || lpKey == NULL)
+        {
+                // Invalid section or key name, just return the default string
+                if (lpDefault == NULL)
+                {
+                        // Empty string
+                        psz = new TCHAR[1];
+                        *psz = _T('\0');
+                }
+                else
+                {
+                        psz = new TCHAR[_tcslen(lpDefault) + 1];
+                        _tcscpy(psz, lpDefault);
+                }
+                return psz;
+        }
+        // Keep enlarging the buffer size until being certain on that the string we
+        // retrieved was original(not truncated).
+        DWORD dwLen = DEF_PROFILE_THRESHOLD;
+        psz = new TCHAR[dwLen + 1];
+        DWORD dwCopied = ::GetPrivateProfileString(lpSection, lpKey, lpDefault == NULL ? _T("") : lpDefault, psz, dwLen, m_pszPathName);
+        while (dwCopied + 1 >= dwLen)
+        {
+                dwLen += DEF_PROFILE_THRESHOLD;
+                delete [] psz;
+                psz = new TCHAR[dwLen + 1];
+                dwCopied = ::GetPrivateProfileString(lpSection, lpKey, lpDefault == NULL ? _T("") : lpDefault, psz, dwLen, m_pszPathName);
+        }
+        return psz; // !!! Requires the caller to free this memory !!!
+}
+// Split a string usinf a particular delimiter, split result are copied into lpBuffer
+// in the "double null terminated string" format as the following figure shows:
+// xxx\0xxxx\0xx\0xxx\0\0
+//
+// For example, if the delimiter is ",", then string "ab,cd,e" will be
+// splitted into "ab\0cd\0e\0\0", this string format can be parsed into an array
+// of sub strings easily using user defined functions or CIni::ParseStringArray.
+DWORD CIni::__StringSplit(LPCTSTR lpString, LPTSTR lpBuffer, DWORD dwBufSize, LPCTSTR lpDelimiter, BOOL bTrimString)
+{
+        if (lpString == NULL || lpBuffer == NULL || dwBufSize == 0)
+                return 0;
+        DWORD dwCopied = 0;
+        *lpBuffer = _T('\0');
+        if (*lpString == _T('\0'))
+                return 0;
+        // If lpDelimiter is NULL, use the default delimiter ",", if delimiter length
+        // is 0, then return whole string
+        if (lpDelimiter != NULL && *lpDelimiter == _T('\0'))
+        {
+                _tcsncpy(lpBuffer, lpString, dwBufSize - 1);
+                return _tcslen(lpBuffer);
+        }
+        LPTSTR pszDel = (lpDelimiter == NULL) ? _tcsdup(DEF_PROFILE_DELIMITER) : _tcsdup(lpDelimiter);
+        const DWORD DEL_LEN = _tcslen(pszDel);
+        LPTSTR lpTarget = lpBuffer;
+        // Search through lpString for delimiter matches, and extract sub strings out
+        LPCTSTR lpPos = lpString;
+        LPCTSTR lpEnd = _tcsstr(lpPos, pszDel);
+        while (lpEnd != NULL)
+        {
+                LPTSTR pszSeg = __StrDupEx(lpPos, lpEnd);
+                if (bTrimString)
+                        __TrimString(pszSeg);
+                const DWORD SEG_LEN = _tcslen(pszSeg);
+                const DWORD COPY_LEN = min(SEG_LEN, dwBufSize - dwCopied);
+                // Need to avoid buffer overflow
+                if (COPY_LEN > 0)
+                {
+                        dwCopied += COPY_LEN + 1;
+                        _tcsncpy(lpTarget, pszSeg, COPY_LEN);
+                        lpTarget[COPY_LEN] = _T('\0');
+                        lpTarget = &lpTarget[SEG_LEN + 1];
+                }
+                delete [] pszSeg;
+                lpPos = &lpEnd[DEL_LEN]; // Advance the pointer for next search
+                lpEnd = _tcsstr(lpPos, pszDel);
+        }
+        // The last part of string, there may not be the trailing delimiter, so we
+        // need to take care of this part, too
+        LPTSTR pszSeg = _tcsdup(lpPos);
+        if (bTrimString)
+                __TrimString(pszSeg);
+        const DWORD SEG_LEN = _tcslen(pszSeg);
+        const DWORD COPY_LEN = min(SEG_LEN, dwBufSize - dwCopied);
+        if (COPY_LEN > 0)
+        {
+                dwCopied += COPY_LEN + 1;
+                _tcsncpy(lpTarget, pszSeg, COPY_LEN);
+                lpTarget[COPY_LEN] = _T('\0');
+        }
+        delete [] pszSeg;
+        lpBuffer[dwCopied] = _T('\0');
+        delete [] pszDel;
+        return dwCopied;
+}
+// Parse a "double null terminated string", pass each sub string to a user-defined
+// callback function
+BOOL CIni::ParseDNTString(LPCTSTR lpString, SUBSTRPROC lpFnStrProc, LPVOID lpParam)
+{
+        if (lpString == NULL || lpFnStrProc == NULL)
+                return FALSE;
+        LPCTSTR p = lpString;
+        DWORD dwLen = _tcslen(p);
+        while (dwLen > 0)
+        {
+                if (!lpFnStrProc(p, lpParam))
+                        return FALSE;
+                p = &p[dwLen + 1];
+                dwLen = _tcslen(p);
+        }
+        return TRUE;
+}
+// Callback function used to compare elements inside of a
+// "double null terminated string" with a given string. Useful for
+// searching in the section names list.
+BOOL CALLBACK CIni::__SubStrCompare(LPCTSTR lpString1, LPVOID lpParam)
+{
+        assert(lpString1 != NULL);
+        LPCTSTR lpString2 = (LPCTSTR)lpParam;
+        assert(lpString2 != NULL);
+        // if two string matches, return zero to stop the parsing
+        return _tcsicmp(lpString1, lpString2) != 0;
+}
+// Callback function used to process a key-pair, it extracts the
+// key name from the key-pair string
+BOOL CALLBACK CIni:: __KeyPairProc(LPCTSTR lpString, LPVOID lpParam)
+{
+        STR_LIMIT* psl = (STR_LIMIT*)lpParam;
+        if (lpString == NULL || psl== NULL)
+                return FALSE;
+        LPCTSTR p = _tcschr(lpString, _T('='));
+        if (p == NULL || p == lpString)
+                return TRUE;
+        // extract the sub-string on left side of the '='
+        LPTSTR psz = new TCHAR[_tcslen(lpString) + 1];
+#ifndef _VS6_USED
+        int i;
+#endif
+        for (int i = 0; &lpString[i] < p; i++)
+                psz[i] = lpString[i];
+        psz[i] = _T('\0');
+        // trim
+        __TrimString(psz);
+        DWORD dwNameLen = _tcslen(psz);
+        DWORD dwCopyLen = 0;
+        //copy to the buffer
+        if (psl->lpTarget != NULL)
+        {
+                dwCopyLen = (psl->dwRemain > 1) ? min(dwNameLen, psl->dwRemain - 1) : 0;
+                _tcsncpy(psl->lpTarget, psz, dwCopyLen);
+                psl->lpTarget[dwCopyLen] = _T('\0');
+                psl->lpTarget = &(psl->lpTarget[dwCopyLen + 1]);
+                psl->dwRemain -= dwCopyLen + 1;
+        }
+        else
+        {
+                dwCopyLen = dwNameLen;
+        }
+        delete [] psz;
+        psl->dwTotalCopied += dwCopyLen + 1;
+        return TRUE;
+}
+#ifdef __AFXWIN_H__
+// Callback function used to add elements that are extracted from a
+// "double null terminated string" to an MFC CStringArray.
+BOOL CALLBACK CIni::__SubStrAdd(LPCTSTR lpString, LPVOID lpParam)
+{
+        CStringArray* pArray = (CStringArray*)lpParam;
+        if (pArray == NULL || lpString == NULL)
+                return FALSE;
+        pArray->Add(lpString);
+        return TRUE;
+}
+#endif
+// Convert an integer into binary string format
+void CIni::__ToBinaryString(UINT nNumber, LPTSTR lpBuffer, DWORD dwBufSize)
+{
+        if (dwBufSize == 0)
+                return;
+        DWORD dwIndex = 0;
+        do
+        {
+                lpBuffer[dwIndex++] = (nNumber % 2) ? _T('1') : _T('0');
+                nNumber /= 2;
+        } while (nNumber > 0 && dwIndex < dwBufSize);
+        lpBuffer[dwIndex] = _T('\0');
+        _tcsrev(lpBuffer);
+}
+// Make sure the base will be expected value
+int CIni::__ValidateBase(int nBase)
+{
+        switch (nBase)
+        {
+        case BASE_BINARY:
+        case BASE_OCTAL:
+        case BASE_HEXADECIMAL:
+                break;
+        default:
+                nBase = BASE_DECIMAL;
+        }
+        return nBase;
+}
+// Convert a signed integer into string representation, based on its base
+void CIni::__IntToString(int nNumber, LPTSTR lpBuffer, int nBase)
+{
+        switch (nBase)
+        {
+        case BASE_BINARY:
+        case BASE_OCTAL:
+        case BASE_HEXADECIMAL:
+                __UIntToString((UINT)nNumber, lpBuffer, nBase);
+                break;
+        default:
+                _stprintf(lpBuffer, _T("%d"), nNumber);
+                break;
+        }
+}
+// Convert an unsigned integer into string representation, based on its base
+void CIni::__UIntToString(UINT nNumber, LPTSTR lpBuffer, int nBase)
+{
+        switch (nBase)
+        {
+        case BASE_BINARY:
+                __ToBinaryString(nNumber, lpBuffer, DEF_PROFILE_NUM_LEN);
+                break;
+        case BASE_OCTAL:
+                _stprintf(lpBuffer, _T("%o"), nNumber);
+                break;
+        case BASE_HEXADECIMAL:
+                _stprintf(lpBuffer, _T("%X"), nNumber);
+                break;
+        default:
+                _stprintf(lpBuffer, _T("%u"), nNumber);
+                break;
+        }
+}
+BOOL CIni::StringToBool(LPCTSTR lpString, BOOL bDefault)
+{
+        // Default: empty string
+        // TRUE: "true", "yes", non-zero decimal numner
+        // FALSE: all other cases
+        if (lpString == NULL || *lpString == _T('\0'))
+                return bDefault;
+        return (_tcsicmp(lpString, _T("true")) == 0
+                || _tcsicmp(lpString, _T("yes")) == 0
+                || _tcstol(lpString, NULL, BASE_DECIMAL) != 0);
+}
+BOOL CIni::__TrimString(LPTSTR lpString)
+{
+        if (lpString == NULL)
+                return FALSE;
+        BOOL bTrimmed = FALSE;
+        int nLen = _tcslen(lpString);
+        // '\n' and '\r' are actually not possible in this case, but anyway...
+        // Trim right side
+        while (nLen >= 0
+                && (lpString[nLen - 1] == _T(' ')
+                        || lpString[nLen - 1] == _T('\t')
+                        || lpString[nLen - 1] == _T('\r')
+                        || lpString[nLen - 1] == _T('\n')))
+        {
+                lpString[--nLen] = _T('\0');
+                bTrimmed = TRUE;
+        }
+        // Trim left side
+        LPCTSTR p = lpString;
+        while (*p == _T(' ')
+                        || *p == _T('\t')
+                        || *p == _T('\r')
+                        || *p == _T('\n'))
+        {
+                p = &p[1];
+                bTrimmed = TRUE;
+        }
+        if (p != lpString)
+        {
+                LPTSTR psz = _tcsdup(p);
+                _tcscpy(lpString, psz);
+                delete [] psz;
+        }
+        return bTrimmed;
+}
+LPTSTR CIni::__StrDupEx(LPCTSTR lpStart, LPCTSTR lpEnd)
+{
+        const DWORD LEN = ((DWORD)lpEnd - (DWORD)lpStart) / sizeof(TCHAR);
+        LPTSTR psz = new TCHAR[LEN + 1];
+        _tcsncpy(psz, lpStart, LEN);
+        psz[LEN] = _T('\0');
+        return psz; // !!! Requires the caller to free this memory !!!
+}
+/////////////////////////////////////////////////////////////////////////////////
+// End of Cini Class Implementation
+/////////////////////////////////////////////////////////////////////////////////
+// If you are getting this error:
+// ----------------------------------------------------------------------------
+// "fatal error C1010: unexpected end of file while looking for precompiled
+//  header directive"
+//-----------------------------------------------------------------------------
+// Please scroll all the way up and uncomment '#include "stdafx.h"'

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STMFlashLoader/Ini.h
 ,0 → 1,171
+#ifndef __INI_H__
+#define __INI_H__
+#define _VS6_USED
+#include <windows.h>
+#include <tchar.h>
+// If MFC is linked, we will use CStringArray for great convenience
+#ifdef __AFXWIN_H__
+        #include <afxtempl.h>
+#endif
+// Number bases
+#define BASE_BINARY                     2
+#define BASE_OCTAL                      8
+#define BASE_DECIMAL            10
+#define BASE_HEXADECIMAL        16
+//---------------------------------------------------------------
+//          Callback Function Type Definition
+//---------------------------------------------------------------
+// The callback function used for parsing a "double-null terminated string".
+// When called, the 1st parameter passed in will store the newly extracted sub
+// string, the 2nd parameter is a 32-bit user defined data, this parameter can
+// be NULL. The parsing will terminate if this function returns zero. To use
+// the callback, function pointer needs to be passed to "CIni::ParseDNTString".
+typedef BOOL (CALLBACK *SUBSTRPROC)(LPCTSTR, LPVOID);
+class CIni
+{
+public:
+        //-----------------------------------------------------------
+        //    Constructors & Destructor
+        //-----------------------------------------------------------
+        CIni(); // Default constructor
+        CIni(LPCTSTR lpPathName); // Construct with a given file name
+        virtual ~CIni();
+        //-----------------------------------------------------------
+        //    Ini File Path Name Access
+        //-----------------------------------------------------------
+        void SetPathName(LPCTSTR lpPathName); // Specify a new file name
+        DWORD GetPathName(LPTSTR lpBuffer, DWORD dwBufSize) const; // Retrieve current file name
+#ifdef __AFXWIN_H__
+        CString GetPathName() const;
+#endif
+        //------------------------------------------------------------
+        //    String Access
+        //------------------------------------------------------------
+        DWORD GetString(LPCTSTR lpSection, LPCTSTR lpKey, LPTSTR lpBuffer, DWORD dwBufSize, LPCTSTR lpDefault = NULL) const;
+#ifdef __AFXWIN_H__
+        CString GetString(LPCTSTR lpSection, LPCTSTR lpKey, LPCTSTR lpDefault = NULL) const;
+#endif
+        BOOL WriteString(LPCTSTR lpSection, LPCTSTR lpKey, LPCTSTR lpValue) const;
+        // Read a string from the ini file, append it with another string then write it
+        // back to the ini file.
+        BOOL AppendString(LPCTSTR Section, LPCTSTR lpKey, LPCTSTR lpString) const;
+        //------------------------------------------------------------
+        //    Ini File String Array Access
+        //------------------------------------------------------------
+        // Parse the string retrieved from the ini file and split it into a set of sub strings.
+        DWORD GetArray(LPCTSTR lpSection, LPCTSTR lpKey, LPTSTR lpBuffer, DWORD dwBufSize, LPCTSTR lpDelimiter = NULL, BOOL bTrimString = TRUE) const;
+#ifdef __AFXWIN_H__
+        void GetArray(LPCTSTR lpSection, LPCTSTR lpKey, CStringArray* pArray, LPCTSTR lpDelimiter = NULL, BOOL bTrimString = TRUE) const;
+        BOOL WriteArray(LPCTSTR lpSection, LPCTSTR lpKey, const CStringArray* pArray, int nWriteCount = -1, LPCTSTR lpDelimiter = NULL) const;
+#endif
+        //------------------------------------------------------------
+        //    Primitive Data Type Access
+        //------------------------------------------------------------
+        int GetInt(LPCTSTR lpSection, LPCTSTR lpKey, int nDefault, int nBase = BASE_DECIMAL) const;
+        BOOL WriteInt(LPCTSTR lpSection, LPCTSTR lpKey, int nValue, int nBase = BASE_DECIMAL) const;
+        BOOL IncreaseInt(LPCTSTR lpSection, LPCTSTR lpKey, int nIncrease = 1, int nBase = BASE_DECIMAL) const;
+        UINT GetUInt(LPCTSTR lpSection, LPCTSTR lpKey, UINT nDefault, int nBase = BASE_DECIMAL) const;
+        BOOL WriteUInt(LPCTSTR lpSection, LPCTSTR lpKey, UINT nValue, int nBase = BASE_DECIMAL) const;
+        BOOL IncreaseUInt(LPCTSTR lpSection, LPCTSTR lpKey, UINT nIncrease = 1, int nBase = BASE_DECIMAL) const;
+        BOOL GetBool(LPCTSTR lpSection, LPCTSTR lpKey, BOOL bDefault) const;
+        BOOL WriteBool(LPCTSTR lpSection, LPCTSTR lpKey, BOOL bValue) const;
+        BOOL InvertBool(LPCTSTR lpSection, LPCTSTR lpKey) const;
+        double GetDouble(LPCTSTR lpSection, LPCTSTR lpKey, double fDefault) const;
+        BOOL WriteDouble(LPCTSTR lpSection, LPCTSTR lpKey, double fValue, int nPrecision = -1) const;
+        BOOL IncreaseDouble(LPCTSTR lpSection, LPCTSTR lpKey, double fIncrease, int nPrecision = -1) const;
+        TCHAR GetChar(LPCTSTR lpSection, LPCTSTR lpKey, TCHAR cDefault) const;
+        BOOL WriteChar(LPCTSTR lpSection, LPCTSTR lpKey, TCHAR c) const;
+        //------------------------------------------------------------
+        //    User-Defined Data Type & Data Block Access
+        //------------------------------------------------------------
+        POINT GetPoint(LPCTSTR lpSection, LPCTSTR lpKey, POINT ptDefault) const;
+        BOOL WritePoint(LPCTSTR lpSection, LPCTSTR lpKey, POINT pt) const;
+        RECT GetRect(LPCTSTR lpSection, LPCTSTR lpKey, RECT rcDefault) const;
+        BOOL WriteRect(LPCTSTR lpSection, LPCTSTR lpKey, RECT rc) const;
+        DWORD GetDataBlock(LPCTSTR lpSection, LPCTSTR lpKey, LPVOID lpBuffer, DWORD dwBufSize, DWORD dwOffset = 0) const;
+        BOOL WriteDataBlock(LPCTSTR lpSection, LPCTSTR lpKey, LPCVOID lpData, DWORD dwDataSize) const;
+        BOOL AppendDataBlock(LPCTSTR lpSection, LPCTSTR lpKey, LPCVOID lpData, DWORD dwDataSize) const;
+        //------------------------------------------------------------
+        //    Section Operations
+        //------------------------------------------------------------
+        BOOL IsSectionExist(LPCTSTR lpSection) const;
+        DWORD GetSectionNames(LPTSTR lpBuffer, DWORD dwBufSize) const;
+#ifdef __AFXWIN_H__
+        void GetSectionNames(CStringArray* pArray) const;
+#endif
+        BOOL CopySection(LPCTSTR lpSrcSection, LPCTSTR lpDestSection, BOOL bFailIfExist) const;
+        BOOL MoveSection(LPCTSTR lpSrcSection, LPCTSTR lpDestSection, BOOL bFailIfExist = TRUE) const;
+        BOOL DeleteSection(LPCTSTR lpSection) const;
+        //------------------------------------------------------------
+        //    Key Operations
+        //------------------------------------------------------------
+        BOOL IsKeyExist(LPCTSTR lpSection, LPCTSTR lpKey) const;
+        DWORD GetKeyLines(LPCTSTR lpSection, LPTSTR lpBuffer, DWORD dwBufSize) const;
+#ifdef __AFXWIN_H__
+        void GetKeyLines(LPCTSTR lpSection, CStringArray* pArray) const;
+#endif
+        DWORD GetKeyNames(LPCTSTR lpSection, LPTSTR lpBuffer, DWORD dwBufSize) const;
+#ifdef __AFXWIN_H__
+        void GetKeyNames(LPCTSTR lpSection, CStringArray* pArray) const;
+#endif
+        BOOL CopyKey(LPCTSTR lpSrcSection, LPCTSTR lpSrcKey, LPCTSTR lpDestSection, LPCTSTR lpDestKey, BOOL bFailIfExist) const;
+        BOOL MoveKey(LPCTSTR lpSrcSection, LPCTSTR lpSrcKey, LPCTSTR lpDestSection, LPCTSTR lpDestKey, BOOL bFailIfExist = TRUE) const;
+        BOOL DeleteKey(LPCTSTR lpSection, LPCTSTR lpKey) const;
+        //------------------------------------------------------------
+        // Parse a "Double-Null Terminated String"
+        //------------------------------------------------------------
+        static BOOL ParseDNTString(LPCTSTR lpString, SUBSTRPROC lpFnStrProc, LPVOID lpParam = NULL);
+        //------------------------------------------------------------
+        // Check for Whether a String Representing TRUE or FALSE
+        //------------------------------------------------------------
+        static BOOL StringToBool(LPCTSTR lpString, BOOL bDefault = FALSE);
+protected:
+        //------------------------------------------------------------
+        //    Helper Functions
+        //------------------------------------------------------------
+        static LPTSTR __StrDupEx(LPCTSTR lpStart, LPCTSTR lpEnd);
+        static BOOL __TrimString(LPTSTR lpBuffer);
+        LPTSTR __GetStringDynamic(LPCTSTR lpSection, LPCTSTR lpKey, LPCTSTR lpDefault = NULL) const;
+        static DWORD __StringSplit(LPCTSTR lpString, LPTSTR lpBuffer, DWORD dwBufSize, LPCTSTR lpDelimiter = NULL, BOOL bTrimString = TRUE);
+        static void __ToBinaryString(UINT nNumber, LPTSTR lpBuffer, DWORD dwBufSize);
+        static int __ValidateBase(int nBase);
+        static void __IntToString(int nNumber, LPTSTR lpBuffer, int nBase);
+        static void __UIntToString(UINT nNumber, LPTSTR lpBuffer, int nBase);
+        static BOOL CALLBACK __SubStrCompare(LPCTSTR lpString1, LPVOID lpParam);
+        static BOOL CALLBACK __KeyPairProc(LPCTSTR lpString, LPVOID lpParam);
+#ifdef __AFXWIN_H__
+        static BOOL CALLBACK __SubStrAdd(LPCTSTR lpString, LPVOID lpParam);
+#endif
+        //------------------------------------------------------------
+        //    Member Data
+        //------------------------------------------------------------
+        LPTSTR m_pszPathName; // Stores path of the associated ini file
+};
+#endif // #ifndef __INI_H__

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STMFlashLoader/Release/Ini.obj
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STMFlashLoader/Release/STMFlashLoader.obj
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STMFlashLoader/Release/STMFlashLoader.pch
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STMFlashLoader/Release/vc60.idb
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STMFlashLoader/STBLLIB.lib
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STMFlashLoader/STMFlashLoader.cpp
 ,0 → 1,1746
+/******************** (C) COPYRIGHT 2010 STMicroelectronics ********************
+* File Name          : STMFlashLoader.cpp
+* Author             : MCD Application Team
+* Version            : v2.2.0
+* Date               : 05/03/2010
+* Description        : STM Flash Loader command line version
+********************************************************************************
+* THE PRESENT SOFTWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
+* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
+* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
+* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
+* CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
+* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+*******************************************************************************/
+#include "stdafx.h"
+#include "string.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <dos.h>
+#include "../STBLLIB/STBLLIB.h"
+#include "../Files/Files.h"
+#include "ini.h"
+#define NONE = 0;
+#define ODD  = 1;
+#define EVEN = 2;
+typedef enum STATE {OK,KO};
+char MapFile[256];
+PMAPPING pmMapping;
+int TimeBO = 100;
+BOOL SHOW_OK = TRUE;  // Set to TRUE/FALSE to show/hide OK status  messages
+BOOL SHOW_KO = TRUE;  // Set to TRUE/FALSE to show/hide KO status  messages
+/*******************************************************************************************/
+/* Function    : FileExist                                                                 */
+/* IN          : file name                                                                 */
+/* OUT         : boolean                                                                   */
+/* Description : verify if the given file exists                                           */
+/*******************************************************************************************/
+BOOL FileExist(LPCTSTR filename)
+{
+        // Data structure for FindFirstFile
+        WIN32_FIND_DATA findData;
+        // Clear find structure
+        ZeroMemory(&findData, sizeof(findData));
+        // Search the file
+        HANDLE hFind = FindFirstFile( filename, &findData );
+        if ( hFind == INVALID_HANDLE_VALUE )
+        {
+        // File not found
+        return false;
+        }
+        // File found
+        // Release find handle
+        FindClose( hFind );
+        hFind = NULL;
+        // The file exists
+        return true;
+}
+/*******************************************************************************************/
+/* Function    : void man()                                                                */
+/* IN          :                                                                           */
+/* OUT         :                                                                           */
+/* Description : print the manual on the standard output                                   */
+/*******************************************************************************************/
+void man()
+{
+        printf("STMicroelectronics UART Flash Loader command line v2.2.0 \n\n");
+        printf(" Usage : \n\n");
+        printf(" STMFlashLoader.exe [options] [Agrument][[options] [Agrument]...] \n\n");
+        printf("  -?                   (Show this help) \n");
+        printf("  -c                   (Establish connection to the COM port) \n");
+        printf("     --pn  port_nb     : e.g: 1, 2 ..., default 1 \n");
+        printf("     --br  baud_rate   : e.g: 115200, 57600 ..., default 57600 \n");
+        printf("     --db  data_bits   : value in {5,6,7,8} ..., default 8 \n");
+        printf("     --pr  parity      : value in {NONE,ODD,EVEN} ..., default EVEN \n");
+        printf("     --sb  stop_bits   : value in {1,1.5,2} ..., default 1 \n");
+    printf("     --ec  echo        : value OFF or ECHO or LISTEN ..., default is OFF \n");
+        printf("     --co  control     : Enable or Disable RTS and DTR outputs control  \n");
+        printf("                       : value OFF or ON ..., default is OFF \n");
+        printf("     --to  time_out    : (ms) e.g 1000, 2000, 3000 ..., default 5000 \n");
+        printf("  -Rts                 (set Rts line to Hi, Lo)\n");
+        printf("     --State           : State in {Hi, Lo} \n");
+        printf("  -Dtr                 (Set Rts line to Hi, Lo)\n");
+        printf("     --State           : State in {Hi, Lo}\n");
+        printf("  -i  device_name      (e.g STM32_Low-density_16K, [See the Map directory]) \n");
+        printf("  -e                   (erase flash pages\n");
+        printf("     --all all pages   : erase all pages\n");
+        printf("     --sec number_of_pages_group pages_group_codes : erase specified group pages \n");
+        printf("  -u                   (Upload flash contents to a .bin, .hex or .s19 file )\n");
+        printf("     --fn  file_name   : full path name of the file \n");
+        printf("  -d                   (Download the content of a file into MCU flash) \n");
+        printf("     --a   address(hex): start @ in hex ; ignored if it is not a binary file \n");
+        printf("     --fn  file_name   : full path name (.bin, .hex or .s19 file) \n");
+        printf("     --v               : verify after download \n");
+        printf("     --o               : optimize; removes FFs data \n");
+    printf("  -r                   (Run the flash code at the specified address \n");
+        printf("     --a address(hex)  : address in hexadecimal) \n");
+        printf("  -p        (Enable or Disable protections) \n");
+        printf("     --ewp  : enable write protection for sector codes (e.g 1,2,etc.) \n");
+        printf("     --dwp  : disable write protection \n");
+        printf("     --drp  : disable read protection \n");
+    printf("     --erp  : enable read protection, all arguments following this one will fail \n");
+        printf("  -o                   (Get or Set STM32 option bytes: use -d command for STM8!) \n");
+        printf("     --get --fn file_name : get option bytes from the device \n");
+    printf("                            and write it in the specified file \n");
+        printf("     --set --fn file_name : load option bytes from the specified file \n");
+    printf("                            and write it to the device \n");
+        printf("     --set --vals --OPB hex_val : set the specified option byte; OPB in: User, \n");
+    printf("                                  RDP, Data0, Data1, WRP0, WRP1, WRP2, WRP3 \n");
+}
+/*******************************************************************************************/
+/* Function    : ParityToInt                                                               */
+/* IN          : parity as string (NONE, ODD, EVEN)                                        */
+/* OUT         : integer                                                                   */
+/* Description : Get the integer representation of the given parity                        */
+/*******************************************************************************************/
+int ParityToInt(char* parity)
+{
+    if (strcmp(parity,"NONE")==0) return 0;
+    else if(strcmp(parity,"ODD")==0) return 1;
+    else if(strcmp(parity,"EVEN")==0) return 2;
+    else return 2;
+}
+/*******************************************************************************************/
+/* Function    : ModeToInt                                                                 */
+/* IN          : Mode as string (OFF, ECHO, LISTEN)                                        */
+/* OUT         : int                                                                      */
+/* Description : Get the int representation of the given string Mode                       */
+/*******************************************************************************************/
+int ModeToInt(char* status)
+{
+    if (strcmp(status,"OFF")==0) return 0;
+        else if(strcmp(status,"ECHO")==0) return 1;
+        else if(strcmp(status,"LISTEN")==0) return 2;
+    else return 0;
+}
+/*******************************************************************************************/
+/* Function    : StatusToBool                                                              */
+/* IN          : Status as string (ON, OFF)                                                */
+/* OUT         : Bool                                                                      */
+/* Description : Get the boolean representation of the given string ON/OFF                 */
+/*******************************************************************************************/
+bool StatusToBool(char* status)
+{
+    if (strcmp(status,"OFF")==0) return false;
+        else if(strcmp(status,"ON")==0) return true;
+    else return false;
+}
+/*******************************************************************************************/
+/* Function    : Is_Option                                                                 */
+/* IN          : option as string                                                          */
+/* OUT         : boolean                                                                   */
+/* Description : Verify if the given string present an option                              */
+/*******************************************************************************************/
+bool Is_Option(char* option)
+{
+        if (strcmp(option,"-?")==0) return true;
+        else if (strcmp(option,"-c")==0) return true;
+        else if (strcmp(option,"-i")==0) return true;
+        else if (strcmp(option,"-e")==0) return true;
+        else if (strcmp(option,"-u")==0) return true;
+        else if (strcmp(option,"-d")==0) return true;
+        else if (strcmp(option,"-v")==0) return true;
+        else if (strcmp(option,"-p")==0) return true;
+        else if (strcmp(option,"-r")==0) return true;
+        else if (strcmp(option,"-o")==0) return true;
+        else if (strcmp(option,"-Rts")==0) return true;
+        else if (strcmp(option,"-Dtr")==0) return true;
+        else if (strcmp(option,"-Auto")==0) return true;
+    else return false;
+}
+/*******************************************************************************************/
+/* Function    : Is_SubOption                                                              */
+/* IN          : sub-option as string                                                      */
+/* OUT         : boolean                                                                   */
+/* Description : Verify if the given string present a sub-option                           */
+/*******************************************************************************************/
+bool Is_SubOption(char* suboption)
+{
+        if (strcmp(suboption,"--pn")==0) return true;
+        else if (strcmp(suboption,"--br")==0) return true;
+        else if (strcmp(suboption,"--db")==0) return true;
+        else if (strcmp(suboption,"--pr")==0) return true;
+        else if (strcmp(suboption,"--sb")==0) return true;
+        else if (strcmp(suboption,"--ec")==0) return true;
+        else if (strcmp(suboption,"--co")==0) return true;
+        else if (strcmp(suboption,"--to")==0) return true;
+        else if (strcmp(suboption,"--lcs")==0) return true;
+        else if (strcmp(suboption,"--all")==0) return true;
+        else if (strcmp(suboption,"--sec")==0) return true;
+        else if (strcmp(suboption,"--a")==0) return true;
+        else if (strcmp(suboption,"--s")==0) return true;
+        else if (strcmp(suboption,"--fn")==0) return true;
+        else if (strcmp(suboption,"--v")==0) return true;
+        else if (strcmp(suboption,"--o")==0) return true;
+        else if (strcmp(suboption,"--erp")==0) return true;
+        else if (strcmp(suboption,"--drp")==0) return true;
+        else if (strcmp(suboption,"--ewp")==0) return true;
+        else if (strcmp(suboption,"--dwp")==0) return true;
+        else if (strcmp(suboption,"--get")==0) return true;
+        else if (strcmp(suboption,"--set")==0) return true;
+        else if (strcmp(suboption,"--vals")==0) return true;
+        else if (strcmp(suboption,"--RDP")==0) return true;
+        else if (strcmp(suboption,"--User")==0) return true;
+        else if (strcmp(suboption,"--Data0")==0) return true;
+        else if (strcmp(suboption,"--Data1")==0) return true;
+        else if (strcmp(suboption,"--WRP0")==0) return true;
+        else if (strcmp(suboption,"--WRP1")==0) return true;
+        else if (strcmp(suboption,"--WRP2")==0) return true;
+        else if (strcmp(suboption,"--WRP3")==0) return true;
+        else if (strcmp(suboption,"--Hi")==0) return true;
+        else if (strcmp(suboption,"--Lo")==0) return true;
+        else return false;
+}
+/*******************************************************************************************/
+/* Function    : write_debug_info                                                          */
+/* IN          :                                                                           */
+/* OUT         :                                                                           */
+/* Description : print the output messages on the standart output                          */
+/*******************************************************************************************/
+void write_debug_info(char *msg, int page, DWORD addr, float size, STATE status)
+{
+        char d_info[256];
+        if((page==0) && (addr==0) && (size==0))
+        {
+                if(status == OK)
+                   sprintf(d_info, "%s \t\t\t\t [OK] \n", msg);
+            else
+                   sprintf(d_info, "%s \t\t\t\t [KO] \n", msg);
+        }
+        else if(status == OK)
+                sprintf(d_info, "%s \t page %i \t @0x %8X \t size %.2f(KB) \t [OK] \n", msg, page, addr, (float)size);
+        else
+                sprintf(d_info, "%s \t page %i \t @0x %8X \t size %.2f(KB) \t [KO] \n", msg, page, addr, (float)size);
+        if((SHOW_OK && (status == OK)) || (SHOW_KO && (status == KO))) printf(d_info);
+}
+/*******************************************************************************************/
+/* Function    : main                                                                      */
+/* IN          :                                                                           */
+/* OUT         :                                                                           */
+/* Description :                                                                           */
+/*******************************************************************************************/
+int main(int argc, char* argv[])
+{
+    START:
+        BYTE Res = SUCCESS;
+        BYTE User, RDP, Data0, Data1, WRP0, WRP1, WRP2, WRP3;
+        bool WaitForMoreSubOpt = TRUE;
+        //Initializing default serial connection parameters
+        int    portname   = 1;
+        long   BaudRate   = 57600 ;
+        int    DataBits   = 8;
+        int    parity     = ParityToInt("EVEN");
+        double nbStopBit  = 1;
+        int    timeout    = 5000;
+        bool   control    = false;
+        int    nsec     = 0;
+        DWORD  address  = 0x00000000;
+        DWORD  size     = 0x00000000;
+        char*  filename;
+        char   devname[256] = "STM32_Low-density_32K.STmap";
+        bool   Verify = FALSE;
+        bool   optimize = FALSE;
+        int    becho = 0;
+        char Drive[3], Dir[256], Fname[256], Ext[256];
+        char *ptr;
+        bool bAuto = false;
+        if (argc == 1)  // wrong parameters
+                man();
+        else
+        {
+                int arg_index = 1;
+                while(arg_index < argc)
+                {
+                        if(!Is_Option(argv[arg_index]))
+                        {
+                          if (arg_index < argc - 1)
+                                  printf("bad parameter [%s] \n", argv[arg_index]);
+                           if(COM_is_Open())
+                                  COM_Close();
+                                if (bAuto)
+                                        goto Done_Success;
+                          printf("\n Press any key to continue ...");
+                          getchar();
+                          return 1;
+                        }
+                        //============================ Show the man =========================================
+                        if (strcmp(argv[arg_index],"-?")==0)
+                        {
+                                man();
+                                return 0;
+                        }
+                        //=============================== connect ============================================
+                        else if (strcmp(argv[arg_index],"-c")==0)
+                        {
+                           while(arg_index < argc)
+                           {
+                             if (arg_index< argc-1)
+                                         arg_index++;
+                             else
+                                         break;
+                                 if(Is_Option(argv[arg_index])) // Set default connection settings and continue with the next option
+                                         break;
+                                 else if(Is_SubOption(argv[arg_index])) // Get connection settings
+                                 {
+                                         if (arg_index< argc-1)
+                                                 arg_index++;
+                                 else
+                                                 break;
+                                         if (strcmp(argv[arg_index-1],"--pn")==0)       portname = atoi(argv[arg_index]);//port name  (e.g COM1, COM2 ..., default COM1) \n");
+                                         else if (strcmp(argv[arg_index-1],"--br")==0)  BaudRate = atoi(argv[arg_index]);//baud reate (e.g 115200, 128000 ..., default 57600) \n");
+                                         else if (strcmp(argv[arg_index-1],"--db")==0)  DataBits = atoi(argv[arg_index]);//data bits  (in {5,6,7,8} ..., default 8) \n");
+                                         else if (strcmp(argv[arg_index-1],"--pr")==0)  parity   = ParityToInt(argv[arg_index]); //parity     (in {NONE,ODD,EVEN} ..., default EVEN) \n");
+                                         else if (strcmp(argv[arg_index-1],"--sb")==0)  nbStopBit= atof(argv[arg_index]);//stop bits  (in {1,1.5,2} ..., default 1) \n");
+                                         else if (strcmp(argv[arg_index-1],"--to")==0)  timeout  = atoi(argv[arg_index]);//time out   (e.g 1000, 2000, 3000 ..., default 5) \n");
+                                     else if (strcmp(argv[arg_index-1],"--ec")==0)  becho  = ModeToInt(argv[arg_index]); // Echo back mode, default is OFF \n");
+                                     else if (strcmp(argv[arg_index-1],"--co")==0)  control  = StatusToBool(argv[arg_index]); // Outputs Control ON/OFF, default is OFF \n");
+                                 }
+                                 else
+                                 {
+                                         if (arg_index < argc - 1)
+                                                printf("bad parameter [%s] \n", argv[arg_index]);
+                                         if(COM_is_Open())
+                                                COM_Close();
+                                         printf("\n Press any key to continue ... 2");
+                                     getchar();
+                                     return 1;
+                                 }
+                           }
+                           // Apply serial connection settings
+                           TARGET_SetComIntType(0);
+                           SetCOMSettings(portname, BaudRate, DataBits, parity, nbStopBit);
+                           STBL_SetFlowControl(control);
+                           // Opening serial connection
+                           Res = COM_Open();
+                           SetTimeOut(1000);
+                           if ((Res != SUCCESS) && (Res != COM_ALREADY_OPENED))
+                           {
+                                    write_debug_info("Opening Port", 0 ,0, 0, KO);
+                                        printf("Cannot open the com port, the port may \n be used by another application \n");
+                                        if(COM_is_Open())
+                                                COM_Close();
+                                        printf("\n Press any key to continue ... 3");
+                                        getchar();
+                                        return 1;
+                           }
+                           else
+                                   write_debug_info("Opening Port", 0 ,0, 0, OK);
+                           STBL_SetEcho(becho);  // Setting Echo back mode
+                        }
+            //============================ Auto option =======================================
+                        else if (strcmp(argv[arg_index],"-Auto")==0)
+                        {
+                           if (arg_index< argc)
+                                   arg_index++;
+                           else
+                                   break;
+                                bAuto = true;
+                                // BOOT0 = High
+                                STBL_SetDtr(TRUE);
+                                Sleep(50);
+                                // Reset = Low
+                                STBL_SetRts(TRUE);
+                                Sleep(50);
+                                // Reset = High
+                                STBL_SetRts(FALSE);
+                                STBL_SetDtr(FALSE);
+                                Sleep(100);
+        COM_Close();
+    COM_Open();
+                                STBL_SetDtr(TRUE);
+                                Sleep(50);
+                                // Reset = Low
+                                STBL_SetRts(TRUE);
+                                Sleep(50);
+                                // Reset = High
+                                STBL_SetRts(FALSE);
+                                STBL_SetDtr(FALSE);
+                                Sleep(500);
+                                //Sleep(1000);
+                                write_debug_info("Setting device to BOOT0", 0 ,0, 0, OK);
+                                //printf("\n RTS set low. Press any key to continue ... 4");
+                                //getchar();
+                        }
+            //============================ command RTS pin =======================================
+                        else if (strcmp(argv[arg_index],"-Rts")==0)
+                        {
+                                //_sleep(1000);
+                           while(arg_index < argc)
+                           {
+                             if (arg_index< argc-1) arg_index++;
+                             else break;
+                                 if(Is_Option(argv[arg_index])) break;
+                                 else if(Is_SubOption(argv[arg_index]))
+                                 {
+                                         if (strcmp(argv[arg_index],"--Hi")==0)
+                                         {
+                                                 write_debug_info("Set Rts line", 0 ,0, 0,OK);
+                                                 STBL_SetRts(TRUE);
+                                         }
+                                         else if (strcmp(argv[arg_index],"--Lo")==0)
+                                         {
+                                                 write_debug_info("Reset Rts line", 0 ,0, 0,OK);
+                                                 STBL_SetRts(FALSE);
+                                         }
+                                         else
+                                         {
+                                                 write_debug_info("bad parameter [Set Rts line] should be Hi or Lo ", 0 ,0, 0,KO);
+                                                 if (arg_index < argc - 1)
+                                                        printf("bad parameter [%s] \n", argv[arg_index]);
+                                                 if(COM_is_Open())
+                                                        COM_Close();
+                                                 printf("\n Press any key to continue ... 5");
+                                                 getchar();
+                                                 return 1;
+                                         }
+                                 }
+                                 else
+                                 {
+                                         if (arg_index < argc - 1)
+                                                printf("bad parameter [%s] \n", argv[arg_index]);
+                                         if(COM_is_Open())
+                                                COM_Close();
+                                         printf("\n Press any key to continue ... 6");
+                                     getchar();
+                                     return 1;
+                                 }
+                           }
+                        }
+            //============================ command DTR pin =======================================
+                        else if (strcmp(argv[arg_index],"-Dtr")==0)
+                        {
+                           while(arg_index < argc)
+                           {
+                             if (arg_index< argc-1)
+                                         arg_index++;
+                             else
+                                         break;
+                                 if(Is_Option(argv[arg_index]))
+                                         break;
+                                 else if(Is_SubOption(argv[arg_index]))
+                                 {
+                                         if (strcmp(argv[arg_index],"--Hi")==0)
+                                         {
+                                                 write_debug_info("Set Dtr line", 0 ,0, 0,OK);
+                                                 STBL_SetDtr(TRUE);
+                                         }
+                                         else if (strcmp(argv[arg_index],"--Lo")==0)
+                                         {
+                                                 write_debug_info("Reset Dtr line", 0 ,0, 0,OK);
+                                                 STBL_SetDtr(FALSE);
+                                         }
+                                         else
+                                         {
+                                                 write_debug_info("bad parameter [Set Dtr line] should be Hi or Lo ", 0 ,0, 0,KO);
+                                                 if (arg_index < argc - 1)
+                                                        printf("bad parameter [%s] \n", argv[arg_index]);
+                                                 if(COM_is_Open())
+                                                        COM_Close();
+                                                 printf("\n Press any key to continue ... 7");
+                                                 getchar();
+                                                 return 1;
+                                         }
+                                 }
+                                 else
+                                 {
+                     if (arg_index < argc - 1) printf("bad parameter [%s] \n", argv[arg_index]);
+                                         if (arg_index < argc - 1)
+                                                printf("bad parameter [%s] \n", argv[arg_index]);
+                                         if(COM_is_Open())
+                                                COM_Close();
+                                         printf("\n Press any key to continue ... 8");
+                                     getchar();
+                                     return 1;
+                                 }
+                           }
+                        }
+            //============================ ERASE =================================================
+                        else if (strcmp(argv[arg_index],"-e")==0)
+                        {
+                           while(arg_index < argc)
+                           {
+                                 if (!WaitForMoreSubOpt)
+                                         break;
+                             if (arg_index< argc-1)
+                                         arg_index++;
+                             else
+                                         break;
+                                 if(Is_Option(argv[arg_index]))
+                                         break;
+                                 else if(Is_SubOption(argv[arg_index]))
+                                 {
+                                         if (arg_index< argc)
+                                                 arg_index++;
+                                 else
+                                                 break;
+                                           //******************** This section is only for STM8 boot loader *******************
+                                           BYTE Version;
+                                           Commands pCmds;
+                                           CString m_Version;
+                                           if (STBL_GET(&Version, &pCmds) == SUCCESS)
+                                           {
+                                                        m_Version.Format("%x.%x",Version/16, Version & 0x0F)  ;
+                                           }
+                                           CIni Ini((LPCSTR)MapFile);
+                                           if(Ini.IsKeyExist((LPCTSTR)"Product",(LPCTSTR)m_Version))
+                                           {
+                                                   CString E_W_ROUTINEs = Ini.GetString((LPCTSTR)"Product",(LPCTSTR)m_Version, "");
+                                                   CString Path(*__argv);
+                                                   char fullPath [MAX_PATH];
+                                                   GetModuleFileName(0, fullPath, (MAX_PATH));
+                                                   Path=fullPath;
+                                                   int j=Path.ReverseFind('\\')+1;
+                                                   if(j) Path=Path.Left(j);
+                                                   CString ToFind;
+                                                   ToFind.Format("%s%s%s", Path, "STM8_Routines\\", E_W_ROUTINEs);
+                                                   if(!E_W_ROUTINEs.IsEmpty())
+                                                   {
+                                                           if(!FileExist((LPCTSTR)ToFind))
+                                                           {
+                                                                   printf("\n!WARNING the erase or download operation may fail \n EW routines file is missing [%s]\n", ToFind);
+                                                           }
+                                                           else
+                                                           {
+                                                                        HANDLE Image;
+                                                                        if (FILES_ImageFromFile((LPSTR)(LPCSTR)ToFind,&Image, 1)== FILES_NOERROR)
+                                                                        {
+                                                                                FILES_SetImageName(Image,(LPSTR)(LPCSTR)ToFind);
+                                                                                DWORD NbElements;
+                                                                                if (FILES_GetImageNbElement(Image, &NbElements) == FILES_NOERROR)
+                                                                                {
+                                                                                        for (int el=0; el< (int)NbElements;el++)
+                                                                                        {
+                                                                                                IMAGEELEMENT Element={0};
+                                                                                                if (FILES_GetImageElement(Image, el, &Element) == FILES_NOERROR)
+                                                                                                {
+                                                                                                        Element.Data=new BYTE[Element.dwDataLength];
+                                                                                                        if (FILES_GetImageElement(Image, el, &Element) == FILES_NOERROR)
+                                                                                                        {
+                                                                                                                if (STBL_DNLOAD(Element.dwAddress, Element.Data, Element.dwDataLength, FALSE) != SUCCESS)
+                                                                                                                {
+                                                                                                                }
+                                                                                                        }
+                                                                                                }
+                                                                                        }
+                                                                                        // Verify writen data
+                                                                                        BOOL VerifySuccess = TRUE;
+                                                                                        _sleep(100);;
+#ifndef _VS6_USED
+                                                                                        int el;
+#endif
+                                                                                        for (el=0; el< (int)NbElements;el++)
+                                                                                        {
+                                                                                                IMAGEELEMENT Element={0};
+                                                                                                if (FILES_GetImageElement(Image, el, &Element) == FILES_NOERROR)
+                                                                                                {
+                                                                                                        Element.Data=new BYTE[Element.dwDataLength];
+                                                                                                        if (FILES_GetImageElement(Image, el, &Element) == FILES_NOERROR)
+                                                                                                        {
+                                                                                                                if (STBL_VERIFY(Element.dwAddress, Element.Data, Element.dwDataLength, FALSE) != SUCCESS)
+                                                                                                                {
+                                                                                                                        VerifySuccess = FALSE;
+                                                                                                                        char str[255];
+                                                                                                                        sprintf(str, "%s at address :0x%X. \n%s \nPlease disable the write protection then try agin.", "Data not matching ", Element.dwAddress, "The page may be write protected.");
+                                                                                                                        AfxMessageBox(str, MB_OK|MB_ICONEXCLAMATION);
+                                                                                                                        return 1;
+                                                                                                                }
+                                                                                                        }
+                                                                                                }
+                                                                                        }
+                                                                                }
+                                                                        }
+                                                                else
+                                                                        {
+                                                                                 AfxMessageBox("Unable to load data from this file " + ToFind + " ...");
+                                                                                 return -1;
+                                                                        }
+                                                           }
+                                                   }
+                                           }
+                                           else
+                                           {
+                                                   int family = Ini.GetInt((LPCTSTR)"Product",(LPCTSTR)"family", 0);
+                                                   if(family == 3)
+                                                   {
+                                                           printf("\n!WARNING the erase or download operation may fail \n EW routines file is missing\n");
+                                                   }
+                                           }
+                                           //End****************** This section is only for STM8 boot loader *******************
+                                         //End****************** This section is only for STM8 boot loader *******************
+                                           printf("\n ERASING ... \n");
+                                         if (strcmp(argv[arg_index-1],"--all")==0)
+                                         {
+                                                 WaitForMoreSubOpt = false;
+                                                 Res = STBL_ERASE(0xFFFF, NULL);
+                                                 if (Res != SUCCESS)
+                                                         write_debug_info("erasing all pages", 0 ,0, 0, KO);
+                                                 else
+                                                         write_debug_info("erasing all pages", 0 ,0, 0, OK);
+                                         }
+                                         else if (strcmp(argv[arg_index-1],"--sec")==0)
+                                         {
+                                                 WaitForMoreSubOpt = true;
+                                                 nsec = atoi(argv[arg_index]);
+                                                 LPWORD sectors = (LPWORD)malloc(nsec *2 + 2);
+                                                 sectors[0] = 0;
+                                                 for(int i = 1; i<= nsec; i++)
+                                                 {
+                                                        sectors[0]++;
+                                                        arg_index++;
+                                                        sectors[sectors[0]] = atoi(argv[arg_index]);
+                                                 }
+                                                 WaitForMoreSubOpt = false;
+                                                 printf("\nerasing %i sectors : ", sectors[0]);
+#ifndef _VS6_USED
+                                                int i;
+#endif
+                                                 for(i = 1; i<= nsec; i++)
+                                                 {
+                                                        printf("<%i>", sectors[i]);
+                                                 }
+                                                 printf("\n");
+                                                 Res = STBL_ERASE(nsec, (LPBYTE)sectors+2);
+                                                 if (Res != SUCCESS)
+                                                 {
+                                                         write_debug_info("erasing", 0 ,0, 0, KO);
+                                                         if(COM_is_Open())
+                                                                 COM_Close();
+                                                         printf("\n Press any key to continue ... 9");
+                                                         getchar();
+                                                         return 1;
+                                                 }
+                                                 else
+                                                         write_debug_info("erasing", 0 ,0, 0, OK);
+                                                 arg_index++;
+                                         }
+                                 }
+                                 else
+                                 {
+                     if (arg_index < argc - 1)
+                                                printf("bad parameter [%s] \n", argv[arg_index]);
+                                         if(COM_is_Open())
+                                                COM_Close();
+                                         printf("\n Press any key to continue ... 10");
+                                     getchar();
+                                     return 1;
+                                 }
+                           }
+                        }
+                        //============================ UPLOAD ===============================================
+                        else if (strcmp(argv[arg_index],"-u")==0)
+                        {
+                                while(arg_index < argc)
+                                {
+                             if (arg_index< argc-1)
+                                         arg_index++;
+                             else
+                                         break;
+                                 if(Is_Option(argv[arg_index]))
+                                         break;
+                                 else if(Is_SubOption(argv[arg_index]))
+                                 {
+                                         if (arg_index< argc)
+                                                 arg_index++;
+                                 else
+                                                 break;
+                                         /*if (strcmp(argv[arg_index-1],"--a")==0)
+                                         {
+                                                 address = _tcstoul(argv[arg_index], 0, 16) ;
+                                         }
+                                         else if (strcmp(argv[arg_index-1],"--s")==0)
+                                         {
+                                                 size = _tcstoul(argv[arg_index], 0, 16) ;
+                                         }
+                                         else */if (strcmp(argv[arg_index-1],"--fn")==0)
+                                         {
+                                                 filename = argv[arg_index];
+                                         }
+                                 }
+                                 else
+                                 {
+                     if (arg_index < argc - 1)
+                                                printf("bad parameter [%s] \n", argv[arg_index]);
+                                         if(COM_is_Open())
+                                                COM_Close();
+                                         printf("\n Press any key to continue ... 11");
+                                     getchar();
+                                     return 1;
+                                 }
+                           }
+                           printf("\n UPLOADING ... \n\n");
+                           HANDLE Handle;
+                           FILES_CreateImage(&Handle, 0);
+                           FILES_CreateImageFromMapping(&Handle,pmMapping);
+                           DWORD NbElements = 0;
+               if (FILES_GetImageNbElement(Handle, &NbElements) == FILES_NOERROR)
+                           {
+                                   if (NbElements > 0)
+                                   {
+                                                        for(int i = 0; i< (int)NbElements; i++)
+                                                        {
+                                                                IMAGEELEMENT Element={0};
+                                                                // Get element data size
+                                                                if (FILES_GetImageElement(Handle, i, &Element) == FILES_NOERROR)
+                                                                {
+                                                                        //Upload element data
+                                                                        Element.Data = (LPBYTE)malloc(Element.dwDataLength);
+                                                                        if (STBL_UPLOAD(Element.dwAddress, Element.Data, Element.dwDataLength) == SUCCESS)
+                                                                        {
+                                                                           //Insert elment in the Image
+                                                                           write_debug_info("Uploading", i ,Element.dwAddress, (float)Element.dwDataLength/(float)1024, OK);
+                                                                           FILES_SetImageElement(Handle,i,FALSE,Element);
+                                                                        }
+                                                                        else
+                                                                        {
+                                                                                write_debug_info("Uploading", i ,Element.dwAddress, (float)Element.dwDataLength/(float)1024, KO);
+                                                                                if(COM_is_Open())
+                                                                                        COM_Close();
+                                                                                printf("\n Press any key to continue ... 12");
+                                                                                getchar();
+                                                                                return 1;
+                                                                        }
+                                                                }
+                                                        }
+                                   }
+                           }
+                           if(!FileExist((LPCTSTR)filename))
+                           {
+                      printf( "file %s does not exist .. Creating file\n", filename);
+                                          FILE* fp = fopen((LPCTSTR)filename, "a+");
+                                          fclose(fp);
+                           }
+                           printf( "Writing data ...\n");
+                           if (FILES_ImageToFile((LPSTR)(LPCSTR)filename,Handle) != FILES_NOERROR)
+                           {
+                     printf( "cannot write to file %s \n", filename);
+                                         if(COM_is_Open())
+                                                COM_Close();
+                                         printf("\n Press any key to continue ... 13");
+                                     getchar();
+                                     return 1;
+                           }
+                           else
+                   printf("\n Uploaded data is dumped on %s", filename);
+                        }
+                        //============================ Get Device map file name ==============================
+                        else if (strcmp(argv[arg_index],"-i")==0)
+                        {
+                           if (arg_index< argc)
+                                   arg_index++;
+                           else
+                                   break;
+                           sprintf(devname,"%s.STmap", argv[arg_index]);
+                           char Drive[3], Dir[256], Fname[256], Ext[256];
+                           _splitpath(argv[0],Drive,Dir,Fname,Ext);
+                           sprintf(MapFile, "%s%s%s%s", Drive, Dir , "Map\\", devname);
+                           pmMapping = NULL;
+                           WORD size = 0;
+                           WORD PacketSize = 0;
+                           pmMapping = NULL;
+                           WORD Size = 0;
+                           char MapName[256];
+                           // Get the number of sectors in the flash target: pmMapping should be NULL
+                           // number of sectors is returned in the Size value
+                           BYTE PagePerSector = 0;
+                           if (!FileExist((LPCTSTR)MapFile))
+                           {
+                                        printf("This version is not intended to support the <%s> target\n", argv[arg_index]);
+                                    if(COM_is_Open())
+                                                COM_Close();
+                                        printf("\n Press any key to continue ... 14");
+                                        getchar();
+                                        return 1;
+                           }
+                           FILES_GetMemoryMapping((LPSTR)(LPCTSTR)MapFile, &Size, (LPSTR)MapName, &PacketSize, pmMapping, &PagePerSector);
+                           // Allocate the mapping structure memory
+                           pmMapping = (PMAPPING)malloc(sizeof(MAPPING));
+                           pmMapping->NbSectors = 0;
+                           pmMapping->pSectors = (PMAPPINGSECTOR) malloc((Size) * sizeof(MAPPINGSECTOR));
+                           // Get the mapping info
+                           FILES_GetMemoryMapping((LPSTR)(LPCTSTR)MapFile, &Size, (LPSTR)(LPCTSTR)MapName, &PacketSize, pmMapping, &PagePerSector);
+                           SetPaketSize(PacketSize);
+                                          //sending BL config byte (0x7F) & identifing target
+                           Res = STBL_Init_BL();
+                           if (Res == UNREOGNIZED_DEVICE)
+                           {
+                                    write_debug_info("Activating device", 0 ,0, 0, KO);
+                                    if(COM_is_Open())
+                                                COM_Close();
+                                        printf("Unrecognized device... Please, reset your device then try again \n");
+                                        if(COM_is_Open())
+                                                COM_Close();
+                                        printf("Please, reset your device then press any key to continue \n");
+                                        printf("\n Press any key to continue ... 15");
+                                        getchar();
+                                        goto START;
+                           }
+                           else if (Res != SUCCESS)
+                           {
+                                    write_debug_info("Activating device", 0 ,0, 0, KO);
+                                        printf("No response from the target, the Boot loader can not be started. \nPlease, verify the boot mode configuration, reset your device then try again. \n");
+                                        if(COM_is_Open())
+                                                COM_Close();
+                                        printf("Please, reset your device then then press any key to continue \n");
+                                        printf("\n Press any key to continue ... 16");
+                                        getchar();
+                                        goto START;
+                           }
+                           _sleep(TimeBO);
+               write_debug_info("Activating device", 0 ,0, 0, OK);
+                           //Getting Target informations (version, available commands)
+                           BYTE Version ;
+                           Commands pCmds;
+                           Res = STBL_GET(&Version, &pCmds);
+                       if (Res != SUCCESS)
+                           {
+                                        if(COM_is_Open())
+                                                COM_Close();
+                                        printf("\n Press any key to continue ... 17");
+                                        getchar();
+                                        return 1;
+                           }
+                           SetTimeOut(timeout);
+                                if (arg_index< argc)
+                                        arg_index++;
+                            else
+                                        break;
+                        }
+                        //============================ DOWNLOAD ==============================================
+                        else if (strcmp(argv[arg_index],"-d")==0)
+                        {
+                                while(arg_index < argc)
+                                {
+                             if (arg_index< argc-1)
+                                         arg_index++;
+                             else
+                                         break;
+                                 if(Is_Option(argv[arg_index]))
+                                         break;
+                                 else if(Is_SubOption(argv[arg_index]))
+                                 {
+                                         if (arg_index< argc)
+                                                 arg_index++;
+                                 else
+                                                 break;
+                                         if (strcmp(argv[arg_index-1],"--a")==0)
+                                         {
+                                                 address = _tcstoul(argv[arg_index], 0, 16) ;
+                                         }
+                                         else if (strcmp(argv[arg_index-1],"--v")==0)
+                                         {
+                                                 Verify = true;
+                                                 arg_index--;
+                                         }
+                                         else if (strcmp(argv[arg_index-1],"--o")==0)
+                                         {
+                                                 optimize = TRUE;
+                                                 arg_index--;
+                                         }
+                                         else if (strcmp(argv[arg_index-1],"--fn")==0)
+                                         {
+                                                 filename = argv[arg_index];
+                                                 _splitpath(filename,Drive,Dir,Fname,Ext);
+                             ptr=strupr(Ext);
+                             strcpy(Ext, ptr);
+                                         }
+                                 }
+                                 else
+                                 {
+                     if (arg_index < argc - 1)
+                                                printf("bad parameter [%s] \n", argv[arg_index]);
+                                         if(COM_is_Open())
+                                                COM_Close();
+                                         printf("\n Press any key to continue ... 18");
+                                     getchar();
+                                     return 1;
+                                 }
+                           }
+                           PMAPPINGSECTOR pSector = pmMapping->pSectors;
+                           for(int i = 1; i<= (int)pmMapping->NbSectors; i++)
+                           {
+                                   if ((strcmp(Ext, ".BIN")!=0) && (i==0))
+                                  address = pSector->dwStartAddress;
+                               pSector->UseForOperation = TRUE;
+                               pSector++;
+                           }
+                           if(!FileExist((LPCTSTR)filename))
+                           {
+                     printf( "file does not exist %s \n", filename);
+                                         if(COM_is_Open())
+                                                COM_Close();
+                                         printf("\n Press any key to continue ... 19");
+                                     getchar();
+                                     return 1;
+                           }
+                           //****************** This section is only for STM8 boot loader *******************
+                           BYTE Version;
+                           Commands pCmds;
+                           CString m_Version;
+                           if (STBL_GET(&Version, &pCmds) == SUCCESS)
+                           {
+                                        m_Version.Format("%x.%x",Version/16, Version & 0x0F)  ;
+                           }
+                           CIni Ini((LPCSTR)MapFile);
+                           if(Ini.IsKeyExist((LPCTSTR)"Product",(LPCTSTR)m_Version))
+                           {
+                                   CString E_W_ROUTINEs = Ini.GetString((LPCTSTR)"Product",(LPCTSTR)m_Version, "");
+                                   CString Path(*__argv);
+                                   int j=Path.ReverseFind('\\')+1;
+                                   if(j) Path=Path.Left(j);
+                                   CString ToFind;
+                                   ToFind.Format("%s%s%s", Path, "STM8_Routines\\", E_W_ROUTINEs);
+                                   if(!E_W_ROUTINEs.IsEmpty())
+                                   {
+                                           if(!FileExist((LPCTSTR)ToFind))
+                                           {
+                                                   printf("\n!WARNING the erase or download operation may fail \n EW routines file is missing [%s]\n", ToFind);
+                                           }
+                                           else
+                                           {
+                                                        HANDLE Image;
+                                                        if (FILES_ImageFromFile((LPSTR)(LPCSTR)ToFind,&Image, 1)== FILES_NOERROR)
+                                                        {
+                                                                FILES_SetImageName(Image,(LPSTR)(LPCSTR)ToFind);
+                                                                DWORD NbElements;
+                                                                if (FILES_GetImageNbElement(Image, &NbElements) == FILES_NOERROR)
+                                                                {
+                                                                        for (int el=0; el< (int)NbElements;el++)
+                                                                        {
+                                                                                IMAGEELEMENT Element={0};
+                                                                                if (FILES_GetImageElement(Image, el, &Element) == FILES_NOERROR)
+                                                                                {
+                                                                                        Element.Data=new BYTE[Element.dwDataLength];
+                                                                                        if (FILES_GetImageElement(Image, el, &Element) == FILES_NOERROR)
+                                                                                        {
+                                                                                                if (STBL_DNLOAD(Element.dwAddress, Element.Data, Element.dwDataLength, FALSE) != SUCCESS)
+                                                                                                {
+                                                                                                }
+                                                                                        }
+                                                                                }
+                                                                        }
+                                                                        // Verify writen data
+                                                                        BOOL VerifySuccess = TRUE;
+                                                                        _sleep(100);
+#ifndef _VS6_USED
+                                                                        int el;
+#endif
+                                                                        for (el=0; el< (int)NbElements;el++)
+                                                                        {
+                                                                                IMAGEELEMENT Element={0};
+                                                                                if (FILES_GetImageElement(Image, el, &Element) == FILES_NOERROR)
+                                                                                {
+                                                                                        Element.Data=new BYTE[Element.dwDataLength];
+                                                                                        if (FILES_GetImageElement(Image, el, &Element) == FILES_NOERROR)
+                                                                                        {
+                                                                                                if (STBL_VERIFY(Element.dwAddress, Element.Data, Element.dwDataLength, FALSE) != SUCCESS)
+                                                                                                {
+                                                                                                        VerifySuccess = FALSE;
+                                                                                                        char str[255];
+                                                                                                        sprintf(str, "%s at address :0x%X. \n%s \nPlease disable the write protection then try agin.", "Data not matching ", Element.dwAddress, "The page may be write protected.");
+                                                                                                        AfxMessageBox(str, MB_OK|MB_ICONEXCLAMATION);
+                                                                                                        return 1;
+                                                                                                }
+                                                                                        }
+                                                                                }
+                                                                        }
+                                                                }
+                                                        }
+                                                else
+                                                        {
+                                                                 AfxMessageBox("Unable to load data from this file " + ToFind + " ...");
+                                                                 return -1;
+                                                        }
+                                           }
+                                   }
+                           }
+                           else
+                           {
+                                   int family = Ini.GetInt((LPCTSTR)"Product",(LPCTSTR)"family", 0);
+                                   if(family == 3)
+                                   {
+                                                printf("\n!WARNING the erase or download operation may fail \n EW routines file is missing\n");
+                                   }
+                           }
+                           //End****************** This section is only for STM8 boot loader *******************
+                           printf("\n DOWNLOADING ... \n\n");
+                           HANDLE Handle;
+                           if (FILES_ImageFromFile((LPSTR)(LPCSTR)filename,&Handle, 1) == FILES_NOERROR)
+                           {
+                              FILES_SetImageName(Handle,(LPSTR)(LPCSTR)filename);
+                                  DWORD NbElements = 0;
+                                  if (FILES_GetImageNbElement(Handle, &NbElements) == FILES_NOERROR)
+                                  {
+                                                if ( NbElements > 0 )
+                                                {   // if binary file -> change the elemnts address
+                                                        if (strcmp(Ext, ".BIN")==0)
+                                                        {
+                                                                for (int i=0;i< (int)NbElements;i++)
+                                                                {
+                                                                        IMAGEELEMENT Element={0};
+                                                                        if (FILES_GetImageElement(Handle, i, &Element) == FILES_NOERROR)
+                                                                        {
+                                                                           Element.Data= (LPBYTE)malloc(Element.dwDataLength);
+                                                                           if (FILES_GetImageElement(Handle, i, &Element) == FILES_NOERROR)
+                                                                           {
+                                                                                   Element.dwAddress = Element.dwAddress + address;
+                                                                                   FILES_SetImageElement(Handle, i, FALSE, Element);
+                                                                           }
+                                                                        }
+                                                                }
+                                                        }
+                                                }
+                                  }
+                                  FILES_FilterImageForOperation(Handle, pmMapping, OPERATION_UPLOAD, optimize);
+                           }
+                           else
+                           {
+                                        printf("cannot open file %s \n", filename);
+                                        if(COM_is_Open())
+                                                COM_Close();
+                                        printf("\n Press any key to continue ... 20");
+                                        getchar();
+                                        return 1;
+                           }
+                           DWORD NbElements = 0;
+               if (FILES_GetImageNbElement(Handle, &NbElements) == FILES_NOERROR)
+                           {
+                                   for (int el=0; el< (int)NbElements;el++)
+                                   {
+                                                IMAGEELEMENT Element={0};
+                                                if (FILES_GetImageElement(Handle, el, &Element) == FILES_NOERROR)
+                                                {
+                                                   Element.Data= (LPBYTE)malloc(Element.dwDataLength);
+                                                   if (FILES_GetImageElement(Handle, el, &Element) == FILES_NOERROR)
+                                                   {
+                                                          if ((strcmp(Ext, ".BIN")==0) && (el==0))
+                                                              Element.dwAddress = address;
+                                                          if (STBL_DNLOAD(Element.dwAddress, Element.Data, Element.dwDataLength, optimize) != SUCCESS)
+                                                          {
+                                                                  write_debug_info( "downloading", el ,Element.dwAddress, (float)Element.dwDataLength/(float)1024, KO);
+                                                                  write_debug_info("The flash may be read protected; use -p --drp to disable write protection." , 0, 0, 0, KO);
+                                                                  if(COM_is_Open())
+                                                                          COM_Close();
+                                                                  printf("\n Press any key to continue ... 21");
+                                                                  getchar();
+                                                                  return 1;
+                                                          }
+                                                          write_debug_info( "downloading", el ,Element.dwAddress, (float)Element.dwDataLength/(float)1024, OK);
+                                                   }
+                                                }
+                                   }
+                           }
+                           bool VerifySuccess = true;
+                           if (Verify)
+                           {
+                                   printf("\n VERIFYING ... \n\n");
+                                        for (int el=0; el< (int)NbElements;el++)
+                                        {
+                                                IMAGEELEMENT Element={0};
+                                            if (FILES_GetImageElement(Handle, el, &Element) == FILES_NOERROR)
+                                                {
+                                                        Element.Data=(LPBYTE)malloc(Element.dwDataLength);
+                                                        if (FILES_GetImageElement(Handle, el, &Element) == FILES_NOERROR)
+                                                        {
+                                                                if ((strcmp(Ext, ".BIN")==0) && (el==0))
+                                                                Element.dwAddress = address;
+                                                                if (STBL_VERIFY(Element.dwAddress, Element.Data, Element.dwDataLength, optimize) != SUCCESS)
+                                                                {
+                                                                        VerifySuccess = false;
+                                                                        write_debug_info("verifying" ,el ,Element.dwAddress, (float)Element.dwDataLength/(float)1024, KO);
+                                    write_debug_info("some pages may be write protected; use -p --dwp to disable write protection." , 0, 0, 0, KO);
+                                                                        if(COM_is_Open())
+                                                                                COM_Close();
+                                                                        printf("\n Press any key to continue ... 22");
+                                                                        getchar();
+                                                                        return 1;
+                                                                }
+                                                                write_debug_info("verifying" ,el ,Element.dwAddress, (float)Element.dwDataLength/(float)1024, OK);
+                                                        }
+                                                }
+                                        }
+                           }
+                        }
+                        //============================ VERIFY ================================================
+                        else if (strcmp(argv[arg_index],"-v")==0)
+                        {
+                                if (arg_index< argc)
+                                        arg_index++;
+                            else
+                                        break;
+                        }
+                        //============================ Program option bytes ==================================
+                        else if (strcmp(argv[arg_index],"-o")==0)
+                        {
+                                while(arg_index < argc)
+                                {
+                             if (arg_index< argc-1)
+                                         arg_index++;
+                             else
+                                         break;
+                                 if(Is_Option(argv[arg_index]))
+                                         break;
+                                 else if(Is_SubOption(argv[arg_index]))
+                                 {
+                                         if (arg_index< argc)
+                                                 arg_index++;
+                                 else
+                                                 break;
+                                         if (strcmp(argv[arg_index-1],"--get")==0)
+                                         {
+                                                 if (arg_index< argc)
+                                                         arg_index++;
+                                     else
+                                                         break;
+                         if (strcmp(argv[arg_index-1],"--fn")==0)
+                                               filename = argv[arg_index];
+                                                 if(TARGET_GetSIFData(&User, &RDP, &Data0, &Data1, &WRP0, &WRP1, &WRP2, &WRP3) == SUCCESS)
+                                                 {
+                                                   write_debug_info("Getting Option bytes  data" ,0 ,0, 0, OK);
+                                               HANDLE Image;
+                                                   if (FILES_CreateImage(&Image, 1) == FILES_NOERROR)
+                                                   {
+                                                                IMAGEELEMENT Element={0};
+                                                                Element.dwAddress   = 0x1FFFF800;
+                                                                Element.dwDataLength = 16;
+                                                                Element.Data = (LPBYTE)malloc(Element.dwDataLength);
+                                                                {
+                                                                        Element.Data[0]  = RDP;
+                                                                        Element.Data[1]  = ~RDP;
+                                                                        Element.Data[2]  = User;
+                                                                        Element.Data[3]  = ~User;
+                                                                        Element.Data[4]  = Data0;
+                                                                        Element.Data[5]  = ~Data0;
+                                                                        Element.Data[6]  = Data1;
+                                                                        Element.Data[7]  = ~Data1;
+                                                                        Element.Data[8]  = WRP0;
+                                                                        Element.Data[9]  = ~WRP0;
+                                                                        Element.Data[10] = WRP1;
+                                                                        Element.Data[11] = ~WRP1;
+                                                                        Element.Data[12] = WRP2;
+                                                                        Element.Data[13] = ~WRP2;
+                                                                        Element.Data[14] = WRP3;
+                                                                        Element.Data[15] = ~WRP3;
+                                                                }
+                                                                FILES_SetImageElement(Image,0,TRUE,Element);
+                                                                if (FILES_ImageToFile((LPSTR)(LPCSTR)filename,Image) != FILES_NOERROR)
+                                                                {
+                                                                    write_debug_info("Saving Option bytes  data",0 ,0, 0, KO);
+                                                                }
+                                                                else  write_debug_info("Saving Option bytes  data",0 ,0, 0, OK);
+                                                   }
+                                                 }
+                                                 else write_debug_info("Getting Option bytes  data" ,0 ,0, 0, KO);
+                                         }
+                                         else if (strcmp(argv[arg_index-1],"--set")==0)
+                                         {
+                                                 if (arg_index< argc) arg_index++;
+                                     else break;
+                         if (strcmp(argv[arg_index-1],"--fn")==0)
+                                                 {
+                                                   filename = argv[arg_index];
+                                                           HANDLE OPBImage;
+                                                           if(!FileExist((LPCTSTR)filename))
+                                                           {
+                                                                          printf( "file does not exist %s \n", filename);
+                                                                          if(COM_is_Open())
+                                                                                  COM_Close();
+                                                                          printf("\n Press any key to continue ... 23");
+                                                                          getchar();
+                                                                          return 1;
+                                                           }
+                                                           if (FILES_ImageFromFile((LPSTR)(LPCSTR)filename, &OPBImage, 0) == FILES_NOERROR)
+                                                           {
+                                                                   DWORD NbElements = 0;
+                                                                   if (FILES_GetImageNbElement(OPBImage, &NbElements) == FILES_NOERROR)
+                                                                   {
+                                                                           if ( NbElements == 1 )
+                                                                           {
+                                                                                  IMAGEELEMENT Element={0};
+                                                                                  if (FILES_GetImageElement(OPBImage, 0, &Element) == FILES_NOERROR)
+                                                                                  {
+                                                                                          Element.Data= (LPBYTE)malloc(Element.dwDataLength);
+                                                                                          if (FILES_GetImageElement(OPBImage, 0, &Element) == FILES_NOERROR)
+                                                                                          {
+                                                                                                  RDP   = Element.Data[0] ;
+                                                                                                  User  = Element.Data[2] ;
+                                                                                                  Data0 = Element.Data[4] ;
+                                                                                                  Data1 = Element.Data[6] ;
+                                                                                                  WRP0  = Element.Data[8] ;
+                                                                                                  WRP1  = Element.Data[10];
+                                                                                                  WRP2  = Element.Data[12];
+                                                                                                  WRP3  = Element.Data[14];
+                                                                                                  if (TARGET_SetSIFData(User, RDP, Data0, Data1, WRP0, WRP1, WRP2, WRP3) == SUCCESS)
+                                                                                                  {
+                                                                                                          write_debug_info("Setting Option bytes  data" ,0 ,0, 0, OK);
+                                                                                                          if(COM_is_Open())
+                                                                                                                  COM_Close();
+                                                                                                          COM_Open();
+                                                                                                          if(STBL_Init_BL() != SUCCESS)
+                                                                                                                  write_debug_info("Resetting device" ,0 ,0, 0, KO);
+                                                                                                          else
+                                                                                                                  write_debug_info("Resetting device" ,0 ,0, 0, OK);
+                                                                                                  }
+                                                                                                  else
+                                                                                                          write_debug_info("Setting Option bytes  data" ,0 ,0, 0, KO);
+                                                                                          }
+                                                                                  }
+                                                                           }
+                                                                   }
+                                                           }
+                                                 }
+                                                 else if (strcmp(argv[arg_index-1],"--vals")==0)
+                                                 {
+                                                           TARGET_GetSIFData(&User, &RDP, &Data0, &Data1, &WRP0, &WRP1, &WRP2, &WRP3);
+                                                           while(arg_index< argc)
+                                                           {
+                                                                   if(Is_Option(argv[arg_index]))
+                                                                           break;
+                                                   else if(Is_SubOption(argv[arg_index]))
+                                                                   {
+                                                                           arg_index++;
+                                                                           if(strcmp(argv[arg_index-1],"--RDP")==0)       { RDP   = _tcstoul(argv[arg_index], 0, 16);arg_index++;}
+                                                                           else if(strcmp(argv[arg_index-1],"--User")==0) { User  = _tcstoul(argv[arg_index], 0, 16);arg_index++;}
+                                                                           else if(strcmp(argv[arg_index-1],"--data0")==0){ Data0 = _tcstoul(argv[arg_index], 0, 16);arg_index++;}
+                                                                           else if(strcmp(argv[arg_index-1],"--data1")==0){ Data1 = _tcstoul(argv[arg_index], 0, 16);arg_index++;}
+                                                                           else if(strcmp(argv[arg_index-1],"--WRP0")==0) { WRP0  = _tcstoul(argv[arg_index], 0, 16);arg_index++;}
+                                                                           else if(strcmp(argv[arg_index-1],"--WRP1")==0) { WRP1  = _tcstoul(argv[arg_index], 0, 16);arg_index++;}
+                                                                           else if(strcmp(argv[arg_index-1],"--WRP2")==0) { WRP2  = _tcstoul(argv[arg_index], 0, 16);arg_index++;}
+                                                                           else if(strcmp(argv[arg_index-1],"--WRP3")==0) { WRP3  = _tcstoul(argv[arg_index], 0, 16);arg_index++;}
+                                                                   }
+                                                           }
+                               if (TARGET_SetSIFData(User, RDP, Data0, Data1, WRP0, WRP1, WRP2, WRP3) != SUCCESS)
+                                                                   write_debug_info("Setting Option bytes  data" ,0 ,0, 0, KO);
+                                                           else
+                                                           {
+                                                                    write_debug_info("Setting Option bytes  data" ,0 ,0, 0, OK);
+                                                                        if(COM_is_Open())
+                                                                                COM_Close();
+                                                                        COM_Open();
+                                                                        if(STBL_Init_BL() != SUCCESS)
+                                                                                write_debug_info("Resetting device" ,0 ,0, 0, KO);
+                                                                        else
+                                                                                write_debug_info("Resetting device" ,0 ,0, 0, OK);
+                                                           }
+                                                           arg_index--;
+                                                 }
+                                         }
+                                 }
+                                 else
+                                 {
+                     if (arg_index < argc - 1)
+                                                printf("bad parameter [%s] \n", argv[arg_index]);
+                                         if(COM_is_Open())
+                                                COM_Close();
+                                         printf("\n Press any key to continue ... 24");
+                                     getchar();
+                                     return 1;
+                                 }
+                           }
+                        }
+                        //============================ Set/Unset R/W protection ==========================
+                        else if (strcmp(argv[arg_index],"-p")==0)
+                        {
+                                while(arg_index < argc)
+                                {
+                             if (arg_index< argc-1)
+                                         arg_index++;
+                             else
+                                         break;
+                                 if(Is_Option(argv[arg_index]))
+                                         break;
+                                 else if(Is_SubOption(argv[arg_index]))
+                                 {
+                                         if (arg_index< argc)
+                                                 arg_index++;
+                                 else
+                                                 break;
+                                         if (strcmp(argv[arg_index-1],"--erp")==0)
+                                         {
+                                                 if(STBL_READOUT_PROTECT() != SUCCESS)
+                                                         write_debug_info( "enabling read protection", 0 , 0, 0, KO);
+                                                 else
+                                                         write_debug_info( "enabling read protection", 0 , 0, 0, OK);
+                                                 _sleep(TimeBO);
+                                 if(STBL_Init_BL() != SUCCESS)
+                                                         write_debug_info( "reseting device", 0 , 0, 0, KO);
+                                                 else
+                                                         write_debug_info( "reseting device", 0 , 0, 0, OK);
+                                                 arg_index--;
+                                         }
+                                         else if (strcmp(argv[arg_index-1],"--drp")==0)
+                                         {
+                                                 if(STBL_READOUT_PERM_UNPROTECT() == SUCCESS)
+                                                 {
+                                                         write_debug_info( "disabling read protection", 0 , 0, 0, OK);
+                                                         _sleep(TimeBO);
+                                     if(STBL_Init_BL() != SUCCESS)
+                                                                 write_debug_info( "reseting device", 0 , 0, 0, KO);
+                                                     else
+                                                                 write_debug_info( "reseting device", 0 , 0, 0, OK);
+                                                 }
+                                                 else
+                                                         write_debug_info( "disabling read protection", 0 , 0, 0, KO);
+                                                 arg_index--;
+                                         }
+                                         else if (strcmp(argv[arg_index-1],"--ewp")==0)
+                                         {
+                                                 LPBYTE sectors;
+                                                 if(Is_Option(argv[arg_index])) break;
+                                                 nsec = atoi(argv[arg_index]);
+                                                 sectors = (LPBYTE)malloc(nsec + 1);
+                                                 sectors[0] = 0;
+                                                 for(int i = 1; i<= nsec; i++)
+                                                 {
+                                                                sectors[0]++;
+                                                                arg_index++;
+                                                                sectors[sectors[0]] = atoi(argv[arg_index]);
+                                                 }
+                                                 printf("\nenabling write protection %i sectors : ", sectors[0]);
+#ifndef _VS6_USED
+                                                int i;
+#endif
+                                                 for(i = 1; i<= nsec; i++)
+                                                 {
+                                                        printf("<%i>", sectors[i]);
+                                                 }
+                                                 printf("\n");
+                                                 if(STBL_WRITE_PROTECT(((LPBYTE)sectors)[0],&((LPBYTE)sectors)[1]) != SUCCESS)
+                                                         write_debug_info( "enabling write protection", 0 , 0, 0, KO);
+                                                 else
+                                                         write_debug_info( "enabling write protection", 0 , 0, 0, OK);
+                                                 _sleep(TimeBO);
+                                 if(STBL_Init_BL() != SUCCESS)
+                                                         write_debug_info( "reseting device", 0 , 0, 0, KO);
+                                                 else
+                                                         write_debug_info( "reseting device", 0 , 0, 0, OK);
+                                         }
+                                         else if (strcmp(argv[arg_index-1],"--dwp")==0)
+                                         {
+                                                 if(STBL_WRITE_PERM_UNPROTECT() != SUCCESS)
+                                                         write_debug_info( "disabling write protection", 0 , 0, 0, KO);
+                                                 else
+                                                         write_debug_info( "disabling write protection", 0 , 0, 0, OK);
+                                                 _sleep(TimeBO);
+                                 if(STBL_Init_BL() != SUCCESS)
+                                                         write_debug_info( "reseting device", 0 , 0, 0, KO);
+                                                 else
+                                                         write_debug_info( "reseting device", 0 , 0, 0, OK);
+                                                 arg_index--;
+                                         }
+                                 }
+                                 else
+                                 {
+                     if (arg_index < argc - 1)
+                                                printf("bad parameter [%s] \n", argv[arg_index]);
+                                         if(COM_is_Open())
+                                                COM_Close();
+                                         printf("\n Press any key to continue ... 25");
+                                     getchar();
+                                     return 1;
+                                 }
+                           }
+                        }
+                        //============================ Run at address ========================================
+                        else if (strcmp(argv[arg_index],"-r")==0)
+                        {
+                                while(arg_index < argc)
+                                {
+                             if (arg_index< argc-1)
+                                         arg_index++;
+                             else
+                                         break;
+                                 if(Is_Option(argv[arg_index]))
+                                         break;
+                                 else if(Is_SubOption(argv[arg_index]))
+                                 {
+                                         if (arg_index< argc)
+                                                 arg_index++;
+                                 else
+                                                 break;
+                                         PMAPPINGSECTOR pSector = pmMapping->pSectors;
+                                     address = pSector->dwStartAddress;
+                                         if (strcmp(argv[arg_index-1],"--a")==0)
+                                         {
+                                                 address = _tcstoul(argv[arg_index], 0, 16) ;
+                                         }
+                                 }
+                                 else
+                                 {
+                     if (arg_index < argc - 1)
+                                                printf("bad parameter [%s] \n", argv[arg_index]);
+                                         if(COM_is_Open())
+                                                COM_Close();
+                                         printf("\n Press any key to continue ... 26");
+                                     getchar();
+                                     return 1;
+                                 }
+                                 if (STBL_GO(address) == SUCCESS)
+                                 {
+                                         printf("Your code is running...\n");
+                                 }
+                                 else
+                                 {
+                                         printf( "run fails \n");
+                                 }
+                           }
+                        }
+                        else
+                        {
+                                if (arg_index < argc - 1)
+                                                printf("bad parameter [%s] \n", argv[arg_index]);
+                                if(COM_is_Open())
+                                        COM_Close();
+                                printf("\n Press any key to continue ... 27");
+                                getchar();
+                                return 1;
+                        }
+                }
+        }
+Done_Success:
+        if (bAuto)
+        {
+                // commented
+                STBL_SetDtr(FALSE);
+                Sleep(50);
+           if(COM_is_Open())
+                        COM_Close();
+                COM_Open();
+                // Reset = Low
+                STBL_SetRts(TRUE);
+                Sleep(50);
+                write_debug_info("Unset BOOT0 & RESET    ", 0 ,0, 0, OK);
+                // Reset = High
+                STBL_SetRts(FALSE);
+                //      printf("command executed succesfully, press any key to close the COM port and exit");
+                //      printf("\n RTS set high. Press any key to continue ... 28");
+                //      getchar();
+        }
+        printf("\nFlashing done. Enjoy ... \n");
+   if(COM_is_Open())
+                COM_Close();
+        return 0;
+}
+/******************* (C) COPYRIGHT 2010 STMicroelectronics *****END OF FILE******/

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STMFlashLoader/STMFlashLoader.dsp
 ,0 → 1,93
+# Microsoft Developer Studio Project File - Name="STMFlashLoader" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+CFG=STMFlashLoader - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "STMFlashLoader.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "STMFlashLoader.mak" CFG="STMFlashLoader - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "STMFlashLoader - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "STMFlashLoader - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+!IF  "$(CFG)" == "STMFlashLoader - Win32 Release"
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD BASE RSC /l 0x405 /d "NDEBUG"
+# ADD RSC /l 0x405 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+!ELSEIF  "$(CFG)" == "STMFlashLoader - Win32 Debug"
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 2
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /D "_AFXDLL" /YX /FD /GZ /c
+# ADD BASE RSC /l 0x405 /d "_DEBUG"
+# ADD RSC /l 0x405 /d "_DEBUG" /d "_AFXDLL"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 STBLLIB.lib Files.lib STUARTBLLIB.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+!ENDIF
+# Begin Target
+# Name "STMFlashLoader - Win32 Release"
+# Name "STMFlashLoader - Win32 Debug"
+# Begin Source File
+SOURCE=.\Ini.cpp
+# End Source File
+# Begin Source File
+SOURCE=.\STMFlashLoader.cpp
+# End Source File
+# End Target
+# End Project

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STMFlashLoader/STMFlashLoader.dsw
 ,0 → 1,29
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+###############################################################################
+Project: "STMFlashLoader"=".\STMFlashLoader.dsp" - Package Owner=<4>
+Package=<5>
+{{{
+}}}
+Package=<4>
+{{{
+}}}
+###############################################################################
+Global:
+Package=<5>
+{{{
+}}}
+Package=<3>
+{{{
+}}}
+###############################################################################

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STMFlashLoader/STMFlashLoader.ncb
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STMFlashLoader/STMFlashLoader.opt
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STMFlashLoader/STMFlashLoader.plg
 ,0 → 1,27
+<html>
+<body>
+<pre>
+<h1>Build Log</h1>
+<h3>
+--------------------Configuration: STMFlashLoader - Win32 Debug--------------------
+</h3>
+<h3>Command Lines</h3>
+Creating temporary file "C:\DOCUME~1\MIJA~1.ICZ\LOCALS~1\Temp\RSP364.tmp" with contents
+[
+/nologo /MDd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /D "_AFXDLL" /Fp"Debug/STMFlashLoader.pch" /YX /Fo"Debug/" /Fd"Debug/" /FD /GZ /c
+"C:\projekts\ARM-ST32F\sw\UNPACK\Src\STMFlashLoader\STMFlashLoader.cpp"
+]
+Creating command line "cl.exe @C:\DOCUME~1\MIJA~1.ICZ\LOCALS~1\Temp\RSP364.tmp"
+Creating command line "link.exe STBLLIB.lib Files.lib STUARTBLLIB.lib /nologo /subsystem:console /incremental:yes /pdb:"Debug/STMFlashLoader.pdb" /debug /machine:I386 /out:"Debug/STMFlashLoader.exe" /pdbtype:sept  ".\Debug\STMFlashLoader.obj" ".\Debug\Ini.obj" "
+<h3>Output Window</h3>
+Compiling...
+STMFlashLoader.cpp
+Linking...
+<h3>Results</h3>
+STMFlashLoader.exe - 0 error(s), 0 warning(s)
+</pre>
+</body>
+</html>

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STMFlashLoader/STMFlashLoader.rc
 ,0 → 1,102
+// Microsoft Visual C++ generated resource script.
+//
+#include "resource.h"
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "afxres.h"
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION 2,1,0,0
+ PRODUCTVERSION 2,1,0,0
+ FILEFLAGSMASK 0x3fL
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x40004L
+ FILETYPE 0x1L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "CompanyName", "STMicroelectronics"
+            VALUE "FileDescription", "Flash loader command line"
+            VALUE "FileVersion", "2, 1, 0, 0"
+            VALUE "InternalName", "STMFlashLoader"
+            VALUE "LegalCopyright", "Copyright © 2009"
+            VALUE "OriginalFilename", "STMFlashLoader.exe"
+            VALUE "ProductName", "STMicroelectronics STMFlashLoader"
+            VALUE "ProductVersion", "2, 1, 0, 0"
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+TEXTINCLUDE
+BEGIN
+    "resource.h\0"
+END
+TEXTINCLUDE
+BEGIN
+    "#include ""afxres.h""\r\n"
+    "\0"
+END
+TEXTINCLUDE
+BEGIN
+    "\r\n"
+    "\0"
+END
+#endif    // APSTUDIO_INVOKED
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STMFlashLoader/STMFlashLoader.vcproj
 ,0 → 1,281
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+        ProjectType="Visual C++"
+        Version="8.00"
+        Name="STMFlashLoader"
+        ProjectGUID="{5DED8251-B239-46C2-B2EE-087FF8D46398}"
+        Keyword="MFCProj"
+        >
+        <Platforms>
+                <Platform
+                        Name="Win32"
+                />
+        </Platforms>
+        <ToolFiles>
+        </ToolFiles>
+        <Configurations>
+                <Configuration
+                        Name="Release|Win32"
+                        OutputDirectory=".\Release"
+                        IntermediateDirectory=".\Release"
+                        ConfigurationType="1"
+                        InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC60.vsprops"
+                        UseOfMFC="0"
+                        ATLMinimizesCRunTimeLibraryUsage="false"
+                        CharacterSet="2"
+                        >
+                        <Tool
+                                Name="VCPreBuildEventTool"
+                        />
+                        <Tool
+                                Name="VCCustomBuildTool"
+                        />
+                        <Tool
+                                Name="VCXMLDataGeneratorTool"
+                        />
+                        <Tool
+                                Name="VCWebServiceProxyGeneratorTool"
+                        />
+                        <Tool
+                                Name="VCMIDLTool"
+                                TypeLibraryName=".\Release/STMFlashLoader.tlb"
+                                HeaderFileName=""
+                        />
+                        <Tool
+                                Name="VCCLCompilerTool"
+                                Optimization="2"
+                                InlineFunctionExpansion="1"
+                                PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+                                StringPooling="true"
+                                RuntimeLibrary="0"
+                                EnableFunctionLevelLinking="true"
+                                PrecompiledHeaderFile=".\Release/STMFlashLoader.pch"
+                                AssemblerListingLocation=".\Release/"
+                                ObjectFile=".\Release/"
+                                ProgramDataBaseFileName=".\Release/"
+                                WarningLevel="2"
+                                SuppressStartupBanner="true"
+                        />
+                        <Tool
+                                Name="VCManagedResourceCompilerTool"
+                        />
+                        <Tool
+                                Name="VCResourceCompilerTool"
+                                PreprocessorDefinitions="NDEBUG"
+                                Culture="1033"
+                        />
+                        <Tool
+                                Name="VCPreLinkEventTool"
+                        />
+                        <Tool
+                                Name="VCLinkerTool"
+                                AdditionalDependencies="&quot;..\STBLLIB\Release\STBLLIB.lib&quot; ..\Files\Release\Files.lib odbc32.lib odbccp32.lib"
+                                OutputFile="..\BIN\Release\STMFlashLoader.exe"
+                                LinkIncremental="1"
+                                SuppressStartupBanner="true"
+                                ProgramDatabaseFile=".\Release/STMFlashLoader.pdb"
+                                SubSystem="1"
+                                TargetMachine="1"
+                        />
+                        <Tool
+                                Name="VCALinkTool"
+                        />
+                        <Tool
+                                Name="VCManifestTool"
+                        />
+                        <Tool
+                                Name="VCXDCMakeTool"
+                        />
+                        <Tool
+                                Name="VCBscMakeTool"
+                                SuppressStartupBanner="true"
+                                OutputFile=".\Release/STMFlashLoader.bsc"
+                        />
+                        <Tool
+                                Name="VCFxCopTool"
+                        />
+                        <Tool
+                                Name="VCAppVerifierTool"
+                        />
+                        <Tool
+                                Name="VCWebDeploymentTool"
+                        />
+                        <Tool
+                                Name="VCPostBuildEventTool"
+                        />
+                </Configuration>
+                <Configuration
+                        Name="Debug|Win32"
+                        OutputDirectory=".\Debug"
+                        IntermediateDirectory=".\Debug"
+                        ConfigurationType="1"
+                        InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC60.vsprops"
+                        UseOfMFC="1"
+                        ATLMinimizesCRunTimeLibraryUsage="false"
+                        CharacterSet="2"
+                        >
+                        <Tool
+                                Name="VCPreBuildEventTool"
+                        />
+                        <Tool
+                                Name="VCCustomBuildTool"
+                        />
+                        <Tool
+                                Name="VCXMLDataGeneratorTool"
+                        />
+                        <Tool
+                                Name="VCWebServiceProxyGeneratorTool"
+                        />
+                        <Tool
+                                Name="VCMIDLTool"
+                                TypeLibraryName=".\Debug/STMFlashLoader.tlb"
+                                HeaderFileName=""
+                        />
+                        <Tool
+                                Name="VCCLCompilerTool"
+                                Optimization="0"
+                                PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+                                MinimalRebuild="true"
+                                BasicRuntimeChecks="3"
+                                RuntimeLibrary="1"
+                                PrecompiledHeaderFile=".\Debug/STMFlashLoader.pch"
+                                AssemblerListingLocation=".\Debug/"
+                                ObjectFile=".\Debug/"
+                                ProgramDataBaseFileName=".\Debug/"
+                                BrowseInformation="1"
+                                WarningLevel="2"
+                                SuppressStartupBanner="true"
+                                DebugInformationFormat="4"
+                        />
+                        <Tool
+                                Name="VCManagedResourceCompilerTool"
+                        />
+                        <Tool
+                                Name="VCResourceCompilerTool"
+                                PreprocessorDefinitions="_DEBUG"
+                                Culture="1033"
+                        />
+                        <Tool
+                                Name="VCPreLinkEventTool"
+                        />
+                        <Tool
+                                Name="VCLinkerTool"
+                                AdditionalDependencies="&quot;..\STBLLIB\Release\STBLLIB.lib&quot; ..\Files\Release\Files.lib"
+                                OutputFile="..\BIN\Debug\STMFlashLoader.exe"
+                                LinkIncremental="2"
+                                SuppressStartupBanner="true"
+                                GenerateDebugInformation="true"
+                                ProgramDatabaseFile=".\Debug/STMFlashLoader.pdb"
+                                SubSystem="1"
+                                TargetMachine="1"
+                        />
+                        <Tool
+                                Name="VCALinkTool"
+                        />
+                        <Tool
+                                Name="VCManifestTool"
+                        />
+                        <Tool
+                                Name="VCXDCMakeTool"
+                        />
+                        <Tool
+                                Name="VCBscMakeTool"
+                                SuppressStartupBanner="true"
+                                OutputFile=".\Debug/STMFlashLoader.bsc"
+                        />
+                        <Tool
+                                Name="VCFxCopTool"
+                        />
+                        <Tool
+                                Name="VCAppVerifierTool"
+                        />
+                        <Tool
+                                Name="VCWebDeploymentTool"
+                        />
+                        <Tool
+                                Name="VCPostBuildEventTool"
+                        />
+                </Configuration>
+        </Configurations>
+        <References>
+        </References>
+        <Files>
+                <Filter
+                        Name="Source Files"
+                        Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+                        >
+                        <File
+                                RelativePath=".\Ini.cpp"
+                                >
+                        </File>
+                        <File
+                                RelativePath="StdAfx.cpp"
+                                >
+                                <FileConfiguration
+                                        Name="Release|Win32"
+                                        >
+                                        <Tool
+                                                Name="VCCLCompilerTool"
+                                                PreprocessorDefinitions=""
+                                                UsePrecompiledHeader="1"
+                                                PrecompiledHeaderThrough="stdafx.h"
+                                        />
+                                </FileConfiguration>
+                                <FileConfiguration
+                                        Name="Debug|Win32"
+                                        >
+                                        <Tool
+                                                Name="VCCLCompilerTool"
+                                                PreprocessorDefinitions=""
+                                                UsePrecompiledHeader="1"
+                                                PrecompiledHeaderThrough="stdafx.h"
+                                        />
+                                </FileConfiguration>
+                        </File>
+                        <File
+                                RelativePath="STMFlashLoader.cpp"
+                                >
+                                <FileConfiguration
+                                        Name="Release|Win32"
+                                        >
+                                        <Tool
+                                                Name="VCCLCompilerTool"
+                                                PreprocessorDefinitions=""
+                                        />
+                                </FileConfiguration>
+                                <FileConfiguration
+                                        Name="Debug|Win32"
+                                        >
+                                        <Tool
+                                                Name="VCCLCompilerTool"
+                                                PreprocessorDefinitions=""
+                                        />
+                                </FileConfiguration>
+                        </File>
+                        <File
+                                RelativePath=".\STMFlashLoader.rc"
+                                >
+                        </File>
+                </Filter>
+                <Filter
+                        Name="Header Files"
+                        Filter="h;hpp;hxx;hm;inl"
+                        >
+                        <File
+                                RelativePath=".\Ini.h"
+                                >
+                        </File>
+                        <File
+                                RelativePath="StdAfx.h"
+                                >
+                        </File>
+                </Filter>
+                <Filter
+                        Name="Resource Files"
+                        Filter="ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+                        >
+                </Filter>
+        </Files>
+        <Globals>
+        </Globals>
+</VisualStudioProject>

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STMFlashLoader/STUARTBLLIB.lib
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STMFlashLoader/StdAfx.cpp
 ,0 → 1,9
+//  stdafx.cpp : source file that includes just the standard includes
+//      STMFlashLoader.pch will be the pre-compiled header
+//      stdafx.obj will contain the pre-compiled type information
+#include "stdafx.h"
+//  TODO: reference any additional headers you need in STDAFX.H
+//  and not in this file

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STMFlashLoader/StdAfx.h
 ,0 → 1,22
+#if !defined(AFX_STDAFX_H__0581A7FA_DEC6_4D61_B47A_826059363FA9__INCLUDED_)
+#define AFX_STDAFX_H__0581A7FA_DEC6_4D61_B47A_826059363FA9__INCLUDED_
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+#define WIN32_LEAN_AND_MEAN             // Exclude rarely-used stuff from Windows headers
+#include <stdio.h>
+#include <afxcmn.h>                     // MFC support for Windows Common Controls
+#include "../Files/Files.h"
+// TODO: reference additional headers your program requires here
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+#endif // !defined(AFX_STDAFX_H__0581A7FA_DEC6_4D61_B47A_826059363FA9__INCLUDED_)

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STMFlashLoader/resource.h
 ,0 → 1,15
+//{{NO_DEPENDENCIES}}
+// Microsoft Developer Studio generated include file.
+// Used by STMFlashLoader.rc
+//
+// Next default values for new objects
+//
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        101
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1000
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STMicroelectronics Flash  Loader project.dsw
 ,0 → 1,52
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+###############################################################################
+Project: "STBLLIB"=".\STBLLIB\STBLLIB.dsp" - Package Owner=<4>
+Package=<5>
+{{{
+    begin source code control
+    "$/PC/ST Generic Boot Loader/SOFTWARE", UBQAAAAA
+    .
+    end source code control
+}}}
+Package=<4>
+{{{
+}}}
+###############################################################################
+Project: "STMFlashLoader"=".\STMFlashLoader\STMFlashLoader.dsp" - Package Owner=<4>
+Package=<5>
+{{{
+    begin source code control
+    "$/PC/ST Generic Boot Loader/SOFTWARE", UBQAAAAA
+    .
+    end source code control
+}}}
+Package=<4>
+{{{
+    Begin Project Dependency
+    Project_Dep_Name STBLLIB
+    End Project Dependency
+}}}
+###############################################################################
+Global:
+Package=<5>
+{{{
+}}}
+Package=<3>
+{{{
+}}}
+###############################################################################

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STMicroelectronics Flash Loader project.ncb
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STMicroelectronics Flash Loader project.opt
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STMicroelectronics Flash  Loader project.sln
 ,0 → 1,29
+Microsoft Visual Studio Solution File, Format Version 9.00
+# Visual Studio 2005
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "STMFlashLoader", "STMFlashLoader\STMFlashLoader.vcproj", "{5DED8251-B239-46C2-B2EE-087FF8D46398}"
+        ProjectSection(ProjectDependencies) = postProject
+                {F9F56A1E-4355-4CC9-92E9-5815BDC57534} = {F9F56A1E-4355-4CC9-92E9-5815BDC57534}
+        EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "STBLLIB", "STBLLIB\STBLLIB.vcproj", "{F9F56A1E-4355-4CC9-92E9-5815BDC57534}"
+EndProject
+Global
+        GlobalSection(SolutionConfigurationPlatforms) = preSolution
+                Debug|Win32 = Debug|Win32
+                Release|Win32 = Release|Win32
+        EndGlobalSection
+        GlobalSection(ProjectConfigurationPlatforms) = postSolution
+                {5DED8251-B239-46C2-B2EE-087FF8D46398}.Debug|Win32.ActiveCfg = Debug|Win32
+                {5DED8251-B239-46C2-B2EE-087FF8D46398}.Debug|Win32.Build.0 = Debug|Win32
+                {5DED8251-B239-46C2-B2EE-087FF8D46398}.Release|Win32.ActiveCfg = Release|Win32
+                {5DED8251-B239-46C2-B2EE-087FF8D46398}.Release|Win32.Build.0 = Release|Win32
+                {F9F56A1E-4355-4CC9-92E9-5815BDC57534}.Debug|Win32.ActiveCfg = Debug|Win32
+                {F9F56A1E-4355-4CC9-92E9-5815BDC57534}.Debug|Win32.Build.0 = Debug|Win32
+                {F9F56A1E-4355-4CC9-92E9-5815BDC57534}.Release|Win32.ActiveCfg = Release|Win32
+                {F9F56A1E-4355-4CC9-92E9-5815BDC57534}.Release|Win32.Build.0 = Release|Win32
+        EndGlobalSection
+        GlobalSection(SolutionProperties) = preSolution
+                HideSolutionNode = FALSE
+        EndGlobalSection
+EndGlobal

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STUARTBLLIB/Debug/STUARTBLLIB.lib
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STUARTBLLIB/Debug/STUARTBLLIB.res
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STUARTBLLIB/Release/STUARTBLLIB.lib
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STUARTBLLIB/Release/STUARTBLLIB.res
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STUARTBLLIB/STUARTBLLIB.h
 ,0 → 1,486
+/******************** (C) COPYRIGHT 2010 STMicroelectronics ********************
+* File Name          : STUARTBLLIB.h
+* Author             : MCD Application Team
+* Version            : v2.2.0
+* Date               : 05/03/2010
+* Description        : Defines the system memory boot loader protocol interface
+********************************************************************************
+* THE PRESENT SOFTWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
+* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
+* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
+* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
+* CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
+* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+*******************************************************************************/
+#ifndef STDLIB_H
+#define STDLIB_H
+#include "StdAfx.h"
+#include "../CRs232/rs232.h"
+#ifdef STUARTBLLIB_EXPORTS
+#define STUARTBLLIB_API __declspec(dllexport)
+#else
+#define STUARTBLLIB_API __declspec(dllimport)
+#endif
+const BYTE INIT_CON                    = 0x7F;
+const BYTE GET_CMD                     = 0x00; //Get the version and the allowed commands supported by the current version of the boot loader
+const BYTE GET_VER_ROPS_CMD            = 0x01; //Get the BL version and the Read Protection status of the NVM
+const BYTE GET_ID_CMD                  = 0x02; //Get the chip ID
+const BYTE SET_SPEED_CMD               = 0x03; //set the new baudrate
+const BYTE READ_CMD                    = 0x11; //Read up to 256 bytes of memory starting from an address specified by the user
+const BYTE GO_CMD                      = 0x21; //Jump to an address specified by the user to execute (a loaded) code
+const BYTE WRITE_CMD                   = 0x31; //Write maximum 256 bytes to the RAM or the NVM starting from an address specified by the user
+const BYTE ERASE_CMD                   = 0x43; //Erase from one to all the NVM sectors
+const BYTE ERASE_EXT_CMD               = 0x44; //Erase from one to all the NVM sectors
+const BYTE WRITE_PROTECT_CMD           = 0x63; //Enable the write protection in a permanent way for some sectors
+const BYTE WRITE_TEMP_UNPROTECT_CMD    = 0x71; //Disable the write protection in a temporary way for all NVM sectors
+const BYTE WRITE_PERM_UNPROTECT_CMD    = 0x73; //Disable the write protection in a permanent way for all NVM sectors
+const BYTE READOUT_PROTECT_CMD         = 0x82; //Enable the readout protection in a permanent way
+const BYTE READOUT_TEMP_UNPROTECT_CMD  = 0x91; //Disable the readout protection in a temporary way
+const BYTE READOUT_PERM_UNPROTECT_CMD  = 0x92; //Disable the readout protection in a permanent way
+const BYTE SUCCESS                     = 0x00; // No error
+const BYTE ERROR_OFFSET                = 0x00; //error offset
+const BYTE COM_ERROR_OFFSET            = ERROR_OFFSET + 0x00;
+const BYTE NO_CON_AVAILABLE            = COM_ERROR_OFFSET + 0x01;  // No serial port opened
+const BYTE COM_ALREADY_OPENED          = COM_ERROR_OFFSET + 0x02;  // Serial port already opened
+const BYTE CANT_OPEN_COM               = COM_ERROR_OFFSET + 0x03;  // Fail to open serial port
+const BYTE SEND_FAIL                   = COM_ERROR_OFFSET + 0x04;  // send over serial port fail
+const BYTE READ_FAIL                   = COM_ERROR_OFFSET + 0x05;  // Read from serial port fail
+const BYTE SYS_MEM_ERROR_OFFSET        = ERROR_OFFSET + 0x10;
+const BYTE CANT_INIT_BL                = SYS_MEM_ERROR_OFFSET + 0x01; // Fail to start system memory BL
+const BYTE UNREOGNIZED_DEVICE          = SYS_MEM_ERROR_OFFSET + 0x02; // Unreconized device
+const BYTE CMD_NOT_ALLOWED             = SYS_MEM_ERROR_OFFSET + 0x03; // Command not allowed
+const BYTE CMD_FAIL                    = SYS_MEM_ERROR_OFFSET + 0x04; // command failed
+const BYTE PROGRAM_ERROR_OFFSET        = ERROR_OFFSET + 0x20;
+const BYTE INPUT_PARAMS_ERROR          = PROGRAM_ERROR_OFFSET + 0x01;
+const BYTE INPUT_PARAMS_MEMORY_ALLOCATION_ERROR = PROGRAM_ERROR_OFFSET + 0x02;
+enum  ACKS {UNDEFINED=0x00, ST75=0x75, ST79=0x79};
+enum  INTERFACE_TYPE {UART, CAN};
+enum  EBaudRate { brCustom,br110, br300, br600, br1200, br2400, br4800, br9600, br14400, br19200, br38400,
+                  br56000, br57600, br115200, br128000, br256000 };// Port Numbers ( custom or COM1..COM16 }
+enum  EPortNumber { pnCustom,pnCOM1, pnCOM2, pnCOM3, pnCOM4, pnCOM5, pnCOM6, pnCOM7,pnCOM8, pnCOM9, pnCOM10,
+                    pnCOM11, pnCOM12, pnCOM13,pnCOM14, pnCOM15, pnCOM16 };// Data bits ( 5, 6, 7, 8 }
+enum  EDataBits { db5BITS, db6BITS, db7BITS, db8BITS };
+// Stop bits ( 1, 1.5, 2 }
+enum  EStopBits { sb1BITS, sb1HALFBITS, sb2BITS };
+// Parity ( None, odd, even, mark, space }
+enum  EParity { ptNONE, ptODD, ptEVEN, ptMARK, ptSPACE };
+// Hardware Flow Control ( None, None + RTS always on, RTS/CTS }
+enum  EHwFlowControl { hfNONE, hfNONERTSON, hfRTSCTS };
+// Software Flow Control ( None, XON/XOFF }
+enum  ESwFlowControl { sfNONE, sfXONXOFF };
+// What to do with incomplete (incoming} packets ( Discard, Pass }
+enum  EPacketMode { pmDiscard, pmPass };
+enum  OPERATION {NONE, ERASE, UPLOAD, DNLOAD, DIS_R_PROT, DIS_W_PROT, ENA_R_PROT, ENA_W_PROT};
+typedef struct RESULT
+{
+        OPERATION operation;
+        char*     filename;
+    HANDLE    Image;
+}* LPRESULT;
+typedef struct Commands
+{
+        BOOL GET_CMD                    ; //Get the version and the allowed commands supported by the current version of the boot loader
+    BOOL GET_VER_ROPS_CMD           ; //Get the BL version and the Read Protection status of the NVM
+    BOOL GET_ID_CMD                 ; //Get the chip ID
+        BOOL SET_SPEED_CMD                   ; //Change the CAN baudrate
+    BOOL READ_CMD                   ; //Read up to 256 bytes of memory starting from an address specified by the user
+    BOOL GO_CMD                     ; //Jump to an address specified by the user to execute (a loaded) code
+    BOOL WRITE_CMD                  ; //Write maximum 256 bytes to the RAM or the NVM starting from an address specified by the user
+    BOOL ERASE_CMD                  ; //Erase from one to all the NVM sectors
+        BOOL ERASE_EXT_CMD              ; //Erase from one to all the NVM sectors
+    BOOL WRITE_PROTECT_CMD          ; //Enable the write protection in a permanent way for some sectors
+    BOOL WRITE_TEMP_UNPROTECT_CMD   ; //Disable the write protection in a temporary way for all NVM sectors
+    BOOL WRITE_PERM_UNPROTECT_CMD   ; //Disable the write protection in a permanent way for all NVM sectors
+    BOOL READOUT_PROTECT_CMD   ; //Enable the readout protection in a permanent way
+    BOOL READOUT_TEMP_UNPROTECT_CMD ; //Disable the readout protection in a temporary way
+    BOOL READOUT_PERM_UNPROTECT_CMD ; //Disable the readout protection in a permanent way
+}* LPCommands;
+typedef struct TARGET_DESCRIPTOR
+{
+        BYTE Version                    ;
+        BYTE CmdCount                   ;
+        BYTE PIDLen                     ;
+        BYTE* PID                       ;
+        BYTE ROPE                       ;
+        BYTE ROPD                       ;
+        BOOL GET_CMD                    ; //Get the version and the allowed commands supported by the current version of the boot loader
+    BOOL GET_VER_ROPS_CMD           ; //Get the BL version and the Read Protection status of the NVM
+    BOOL GET_ID_CMD                 ; //Get the chip ID
+    BOOL SET_SPEED_CMD              ;
+        BOOL READ_CMD                   ; //Read up to 256 bytes of memory starting from an address specified by the user
+    BOOL GO_CMD                     ; //Jump to an address specified by the user to execute (a loaded) code
+    BOOL WRITE_CMD                  ; //Write maximum 256 bytes to the RAM or the NVM starting from an address specified by the user
+    BOOL ERASE_CMD                  ; //Erase from one to all the NVM sectors
+        BOOL ERASE_EXT_CMD              ; //Erase from one to all the NVM sectors
+    BOOL WRITE_PROTECT_CMD          ; //Enable the write protection in a permanent way for some sectors
+    BOOL WRITE_TEMP_UNPROTECT_CMD   ; //Disable the write protection in a temporary way for all NVM sectors
+    BOOL WRITE_PERM_UNPROTECT_CMD   ; //Disable the write protection in a permanent way for all NVM sectors
+    BOOL READOUT_PERM_PROTECT_CMD   ; //Enable the readout protection in a permanent way
+    BOOL READOUT_TEMP_UNPROTECT_CMD ; //Disable the readout protection in a temporary way
+    BOOL READOUT_PERM_UNPROTECT_CMD ; //Disable the readout protection in a permanent way
+}* LPTARGET_DESCRIPTOR;
+typedef struct STBL_Request
+{
+        BYTE   _cmd;
+        DWORD  _address;
+        WORD   _length;
+        BYTE   _nbSectors;
+    LPTARGET_DESCRIPTOR _target;
+        LPBYTE _data;
+        WORD   _wbSectors;
+}* LPSTBL_Request;
+extern "C"
+{
+/************************************************************************************/
+/* SET COMMUNICATION INTERFACE TYPE
+/* UART - ...
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE TARGET_SetComIntType(BYTE com_int_type);
+/************************************************************************************/
+/* GET PROGRESS STATE
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE GetProgress(LPBYTE progress);
+/************************************************************************************/
+/* GET ACTIVITY TIME
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE GetActivityTime(LPDWORD time);
+/************************************************************************************/
+/* SET ACTIVITY TIME
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE SetActivityTime(DWORD time);
+/************************************************************************************/
+/* GetFlashSize
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE TARGET_GetFlashSize(DWORD Addr, LPWORD val);
+/************************************************************************************/
+/* GetRAMSize
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE TARGET_GetMemoryAddress(DWORD Addr, LPBYTE val);
+/************************************************************************************/
+/* GetRDPOptionByte
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE TARGET_GetRDPOptionByte(LPBYTE RDP);
+/************************************************************************************/
+/* GetWRPOptionBytes
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE TARGET_GetWRPOptionBytes(LPBYTE WRP0, LPBYTE WRP1, LPBYTE WRP2, LPBYTE WRP3);
+/************************************************************************************/
+/* Basic function to send a request
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE Send_RQ(LPSTBL_Request pRQ);
+/************************************************************************************/
+/*
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE SetCOMSettings(int numPort, long speedInBaud, int nbBit,
+                                    int parity, float nbStopBit);
+/************************************************************************************/
+/*
+/*
+/*
+/************************************************************************************/
+/*STUARTBLLIB_API BYTE ESetCOMSettings(EPortNumber numPort, EBaudRate speedInBaud, EDataBits nbBit,
+                                    EParity parity, EStopBits nbStopBit);*/
+/************************************************************************************/
+/*
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE COM_Open();
+/************************************************************************************/
+/*
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE COM_Close();
+/************************************************************************************/
+/*
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE STBL_SetSpeed(DWORD speed);
+/************************************************************************************/
+/*
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE STBL_Init_BL();
+/************************************************************************************/
+/* 0x00; //Get the version and the allowed commands supported by the current version of the boot loader
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE STBL_GET(LPBYTE Version, LPCommands pCmds);
+/************************************************************************************/
+/* 0x01; //Get the BL version and the Read Protection status of the NVM
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE STBL_GET_VER_ROPS(LPBYTE Version, LPBYTE ROPEnabled, LPBYTE ROPDisabled);
+/************************************************************************************/
+/* 0x02; //Get the chip ID
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE STBL_GET_ID(LPBYTE size, LPBYTE pID);
+/************************************************************************************/
+/* 0x11; //Read up to 256 bytes of memory starting from an address specified by the user
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE STBL_READ(DWORD Address, BYTE Size, LPBYTE pData);
+/************************************************************************************/
+/* 0x21; //Jump to an address specified by the user to execute (a loaded) code
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE STBL_GO(DWORD Address);
+/************************************************************************************/
+/* 0x31; //Write maximum 256 bytes to the RAM or the NVM starting from an address specified by the user
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE STBL_WRITE(DWORD address, BYTE size, LPBYTE pData);
+/************************************************************************************/
+/* 0x43; //Erase from one to all the NVM sectors
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE STBL_ERASE(WORD NbSectors, LPBYTE pSectors);
+/************************************************************************************/
+/* 0x63; //Enable the write protection in a permanent way for some sectors
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE STBL_WRITE_PROTECT(BYTE NbSectors, LPBYTE pSectors);
+/************************************************************************************/
+/* 0x71; //Disable the write protection in a temporary way for all NVM sectors
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE STBL_WRITE_TEMP_UNPROTECT();
+/************************************************************************************/
+/* 0x73; //Disable the write protection in a permanent way for all NVM sectors
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE STBL_WRITE_PERM_UNPROTECT();
+/************************************************************************************/
+/* 0x82; //Enable the readout protection in a permanent way
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE STBL_READOUT_PROTECT();
+/************************************************************************************/
+/* 0x91; //Disable the readout protection in a temporary way
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE STBL_READOUT_TEMP_UNPROTECT();
+/************************************************************************************/
+/* 0x92; //Disable the readout protection in a permanent way
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE STBL_READOUT_PERM_UNPROTECT();
+/************************************************************************************/
+/* UPLOAD
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE STBL_UPLOAD(DWORD Address, LPBYTE pData, DWORD Length);
+/************************************************************************************/
+/* VERIFY
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE STBL_VERIFY(DWORD Address, LPBYTE pData, DWORD Length,BOOL bTruncateLeadFFForDnLoad);
+/************************************************************************************/
+/* DNLOAD
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE STBL_DNLOAD(DWORD Address, LPBYTE pData, DWORD Length,BOOL bTruncateLeadFFForDnLoad);
+/************************************************************************************/
+/* SET PACKET SIZE
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE SetPaketSize(BYTE size);
+/************************************************************************************/
+/* GET PACKET SIZE
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE GetPaketSize(LPBYTE size);
+/************************************************************************************/
+/* GetAckValue
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API ACKS GetAckValue();
+/************************************************************************************/
+/* IsConnected
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BOOL COM_is_Open();
+/************************************************************************************/
+/* SetTimeOut
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE SetTimeOut(DWORD vms);
+/************************************************************************************/
+/* GetUserOptionByte
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE TARGET_GetUserOptionByte(LPBYTE User);
+/************************************************************************************/
+/* GetDataOptionByte
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE TARGET_GetDataOptionByte(LPBYTE Data0, LPBYTE Data1);
+/************************************************************************************/
+/* SetSIFData
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE TARGET_SetSIFData(BYTE User, BYTE RDP, BYTE Data0, BYTE Data1,
+                                                                   BYTE WRP0, BYTE WRP1, BYTE WRP2, BYTE WRP3);
+/************************************************************************************/
+/* GetSIFData
+/*
+/*
+/************************************************************************************/
+STUARTBLLIB_API BYTE TARGET_GetSIFData(LPBYTE User, LPBYTE RDP, LPBYTE Data0, LPBYTE Data1,
+                                                                   LPBYTE WRP0, LPBYTE WRP1, LPBYTE WRP2, LPBYTE WRP3);
+/************************************************************************************/
+/* Set Rts Line State
+/*   High = TRUE
+/*   Low  = FALSE
+/************************************************************************************/
+STUARTBLLIB_API BYTE STBL_SetRts(BOOL Val);
+/************************************************************************************/
+/* Set Dtr Line State
+/*   High = TRUE
+/*   Low  = FALSE
+/************************************************************************************/
+STUARTBLLIB_API BYTE STBL_SetDtr(BOOL Val);
+/************************************************************************************/
+/*   Set the state of TXD. Return: true if success.
+/*   High = TRUE
+/*   Low  = FALSE
+/************************************************************************************/
+STUARTBLLIB_API BYTE STBL_setTxd(BOOL val);
+/************************************************************************************/
+/*   Return: The state of CTS.
+/*   High = TRUE
+/*   Low  = FALSE
+/************************************************************************************/
+STUARTBLLIB_API BYTE STBL_getCts(BOOL* pval);
+/************************************************************************************/
+/*   Return: The state of DTR.
+/*   High = TRUE
+/*   Low  = FALSE
+/************************************************************************************/
+STUARTBLLIB_API BYTE STBL_getDtr(BOOL* pval);
+/************************************************************************************/
+/*   Return: The state of RI.
+/*   High = TRUE
+/*   Low  = FALSE
+/************************************************************************************/
+STUARTBLLIB_API BYTE STBL_getRi(BOOL* pval);
+/************************************************************************************/
+/*   Return: The state of DTR.
+/*   High = TRUE
+/*   Low  = FALSE
+/************************************************************************************/
+STUARTBLLIB_API BYTE STBL_getCd(BOOL* pval);
+/************************************************************************************/
+/* Set Echo Mode
+/*   0   =  Echo Disabled
+/*   1   =  Echo Back Enabled
+/*   2   =  Listen Echo Enabled
+/************************************************************************************/
+STUARTBLLIB_API BYTE STBL_SetEcho(int val);
+/************************************************************************************/
+/* SetFlowControl : Enable/Disable Flow Control of DTR and RTS
+/* FALSE   =   Disabled
+/* TRUE    =   Enabled
+/************************************************************************************/
+STUARTBLLIB_API  BYTE STBL_SetFlowControl(bool val);
+}
+#endif
+/******************* (C) COPYRIGHT 2010 STMicroelectronics *****END OF FILE******/

 /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src/STUARTBLLIB/resource.h
 ,0 → 1,15
+//{{NO_DEPENDENCIES}}
+// Microsoft Developer Studio generated include file.
+// Used by STUARTBLLIB.rc
+//
+// Next default values for new objects
+//
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        101
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1000
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif

Subversion Repositories – MLAB

/Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src @ 2060 → /Modules/ARM/STM32F10xRxT/SW/RS232_bootloader/Src @ 2061

Compare Path:	Rev
With Path:	Rev