IADspApplicationPtr pApp;
    TCHAR szVersion[32];

    pApp.CreateInstance( "VisualDSP.ADspApplication" );
    sprintf( szVersion, "IDDE Version: %d.%d",
             pApp->VersionMajor,
             pApp->VersionMinor );

    pApp->PrintText( tabConsole, szVersion );

    Dim app As Application
    Dim strVersion As String

    Set app = CreateObject( "VisualDSP.ADspApplication" )
    strVersion = "IDDE Version: " + CStr( app.VersionMajor ) + "." + CStr( app.VersionMinor )

    app.PrintText tabConsole, strVersion

    IADspApplicationPtr pApp;
    TCHAR szBuffer[128];

    pApp.CreateInstance( "VisualDSP.ADspApplication" );
    IADspDebugSessionPtr pSession = pApp->ActiveSession;
    IADspProcessorPtr pProcessor = pSession->ProcessorList->GetItem( CComVariant( 0 ) );
    IADspBreakpointListPtr pBreakpointList = pProcessor->BreakpointList;

    for ( long i = 0; i < pBreakpointList->Count; i++ )
    {
        IADspBreakpointPtr pBreakpoint = pBreakpointList->GetItem( i );
        sprintf( szBuffer, "File Name = %s  Line Number = %ld  Address = 0x%lx",
                 (char *) pBreakpoint->FileName,
                 pBreakpoint->LineNumber, pBreakpoint->Address );
        pApp->PrintText( tabConsole, szBuffer );
    }

    Dim app As Application
    Dim session As ADspDebugSession
    Dim breakpoint_list As ADspBreakpointList
    Dim breakpoint As ADspBreakpoint
    Dim processor As ADspProcessor

    Set app = CreateObject( "VisualDSP.ADspApplication" )
    Set session = app.ActiveSession
    Set processor = session.ProcessorList( 0 )
    Set breakpoint_list = processor.BreakpointList

    For Each breakpoint In breakpoint_list
        app.PrintText tabConsole, "File Name = "     + breakpoint.FileName + _
                                  "  Line Number = " + CStr( breakpoint.LineNumber ) + _
                                  "  Address = 0x"   + Hex(breakpoint.Address)
    Next

USES_CONVERSION;

long i;

char cj;

char msg[256];

IADspApplicationPtr pApp("VisualDSP.ADspApplication");
IADspPluginPtr pBtcPlugin = pApp->PluginList->GetItem("BtcManager");
IADspBtcManagerPtr pBtcManager = pBtcPlugin->Open();
IADspBtcChannelListPtr pBtcChannelList = pBtcManager->ChannelList((long)0);
IADspBtcChannelPtr pBtcChannel = pBtcChannelList->GetItem((long)0);

sprintf(msg,"Channel Name:     %s \n"
            "Channel Address:  %x \n"
            "Channel Length:   %x \n"
            "Channel Timeout:  %d \n"
            "Supported Widths: %x \n",
            OLE2A(pBtcChannel->Name),
            pBtcChannel->Address,
            pBtcChannel->Length,
            pBtcChannel->Timeout,
            pBtcChannel->SupportedWidths);

pApp->PrintText( tabConsole, msg );

long length = pBtcChannel->Length;

LPSAFEARRAY psaWrite = SafeArrayCreateVector( VT_VARIANT, 0, length );

cj = 0x11;

for( i=0; i < length; i++, cj+=0x22 )
{
   CComVariant var = cj;
   SafeArrayPutElement( psaWrite, &i, &var );
}

CComVariant varWrArray;
varWrArray.vt = VT_ARRAY|VT_VARIANT;
varWrArray.parray = psaWrite;

pApp->PrintText( tabConsole, "Writing data...");
pBtcChannel->Write(adspBtcDataWidth(1), varWrArray);

pApp->PrintText( tabConsole, "Reading data...");
CComVariant varRdArray;
varRdArray = pBtcChannel->Read(adspBtcDataWidth(1));

for( i=0; i < length; i++ )
{
   CComVariant varRd, varWr;
   SafeArrayGetElement( varRdArray.parray, &i, &varRd );
   SafeArrayGetElement( varWrArray.parray, &i, &varWr );
   if (V_UI1(&varRd) != V_UI1(&varWr))
   {
      sprintf(msg, "Data mismatch. wrote: %x  read: %x", V_UI1(&varWr), V_UI1(&varRd));
      pApp->PrintText( tabConsole, msg);
   }
   else
   {
      sprintf(msg, "Data match. wrote: %x  read: %x", V_UI1(&varWr), V_UI1(&varRd));
      pApp->PrintText( tabConsole, msg);
   }
}

pBtcPlugin->Close(pBtcManager);

Dim app

Dim btc_plugin

Dim btc_manager

Dim btc_channel_list

Dim btc_channel

Dim wr_array()

Dim rd_array

Dim length, data, i

Set app = CreateObject( "VisualDSP.ADspApplication" )

Set btc_plugin = app.PluginList("BtcManager")

Set btc_manager = btc_plugin.Open()

Set btc_channel_list = btc_manager.ChannelList(0)

Set btc_channel = btc_channel_list(0)

app.PrintText tabConsole, "Channel Name:    " + btc_channel.Name
app.PrintText tabConsole, "Channel Address: " + Hex(btc_channel.Address)
app.PrintText tabConsole, "Channel Length:  " + Hex(btc_channel.Length)
app.PrintText tabConsole, "Channel Timeout: " + CStr(btc_channel.Timeout)
app.PrintText tabConsole, "SupportedWidths: " + CStr(btc_channel.SupportedWidths)
app.PrintText tabConsole, ""

length = btc_channel.Length

ReDim wr_array(length-1)

data = &H11

For i = 0 To UBound(wr_array)
   wr_array(i) = data
   data = data + &H11

Next

app.PrintText tabConsole, "Writing data..."
btc_channel.Write 1, wr_array

app.PrintText tabConsold, "Reading data..."
rd_array = btc_channel.Read(1)

For i = 0 To UBound(wr_array)
   If wr_array(i) <> rd_array(i) Then
      app.PrintText tabConsole, "Data mismatch. wrote: " + Hex(wr_array(i)) _
                              + " read: " + Hex(rd_array(i)) + "."
   Else
      app.PrintText tabConsole, "Data match. wrote: " + Hex(wr_array(i)) _
                              + " read: " + Hex(rd_array(i)) + "."
   End If

Next

btc_plugin.Close btc_manager

IADspApplicationPtr pApp;
TCHAR szBuffer[4096];

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspDebugSessionPtr pSession = pApp->ActiveSession;
IADspProcessorPtr pProcessor = pSession->ProcessorList->GetItem( CComVariant( 0 ) );
IADspCompilerAnnotationListPtr pCompilerAnnotationList = pProcessor->CompilerAnnotationList;

for ( long i = 0; i < pCompilerAnnotationList->Count; i++ )
{
   IADspCompilerAnnotationPtr pADspCompilerAnnotation = pCompilerAnnotationList->GetItem( i );

   pApp->PrintText( tabConsole,
      "================================================================================" );

   sprintf( szBuffer, "File Name: %s",
          (char *) pADspCompilerAnnotation->FileName );
   pApp->PrintText( tabConsole, szBuffer );

   sprintf( szBuffer, "Line: %d", pADspCompilerAnnotation->Line );
   pApp->PrintText( tabConsole, szBuffer ); 

   sprintf( szBuffer, "Column: %d", pADspCompilerAnnotation->Column );
   pApp->PrintText( tabConsole, szBuffer ); 

   switch ( pADspCompilerAnnotation->Type )
   {
   case compilerAnnotationsTypeInfo:
      sprintf( szBuffer, "[info] %s", (char *) pADspCompilerAnnotation->Text );
      break;
   case compilerAnnotationsTypeAdvice:
      sprintf( szBuffer, "[advice] %s", (char *) pADspCompilerAnnotation->Text );
      break;
   case compilerAnnotationsTypeFailure:
      sprintf( szBuffer, "[failure] %s", (char *) pADspCompilerAnnotation->Text );
      break;
   default:
      sprintf( szBuffer, "[unknown] %s", (char *) pADspCompilerAnnotation->Text );
      break;              
   }
   pApp->PrintText( tabConsole, szBuffer ); 
}

Dim app As Application

Dim session As ADspDebugSession

Dim annotation_list As ADspCompilerAnnotationList

Dim annotation As ADspCompilerAnnotation

Dim processor As ADspProcessor

Set app = CreateObject( "VisualDSP.ADspApplication" )

Set session = app.ActiveSession

Set processor = session.ProcessorList( 0 )

Set annotation_list = processor.HardwareStackList

For Each annotation In annotation_list
   app.PrintText tabConsole, "Name = " + hardware_stack.Name _
                           + "  Width = " + CStr( hardware_stack.Width ) _
                           + "  Depth = " + CStr(hardware_stack.Depth)

   app.PrintText tabConsole, _
      "================================================================================"
   app.PrintText tabConsole, "File Name: " + annotation.FileName
   app.PrintText tabConsole, "Line     : " + cstr(annotation.Line)
   app.PrintText tabConsole, "Column   : " + cstr(annotation.Column)

   If (annotation.Type = 0) Then
      app.PrintText tabConsole, "[info]" + " " + annotation.Text
   Elseif (annotation.Type = 1) Then
      app.PrintText tabConsole, "[advice]" + " " + annotation.Text
   Elseif (annotation.Type = 2) Then
      app.PrintText tabConsole, "[failure]" + " " + annotation.Text
   Else
      app.PrintText tabConsole, "[unknown]" + " " + annotation.Text
   End if

Next

STDMETHODIMP CPlugin::ExtendContextMenu( LPDISPATCH pIADspContextMenu )
{
   // IDDE вызовет этот метод автоматически, когда пользователь сделает
   // правый клик в окне плагина. Это дает возможность добавить любые
   // пункты в контекстное меню.

   try
   {
      IADspContextMenuPtr pMenu = pIADspContextMenu;
      pMenu->AddMenu( "My Menu", ID_MY_MENU, TRUE, TRUE );
      pMenu->AddMenu( "SEPARATOR", 0,  FALSE, FALSE );
      pMenu->AddMenu( "SubMenu:My Menu 2", ID_MY_MENU2, FALSE TRUE );
   }
   catch( _com_error err )
   {
      ASSERT( !"Failed to add context menu" );
   }

   return( S_OK );
}

IADspApplicationPtr pApp( "VisualDSP.ADspApplication" );
IADspCoreFilePluginPtr pCfsPlugin = pApp->PluginList->GetItem("Core File Support")->Open();
IADspCoreFileManagerPtr pMgr = pCfsPlugin->CoreFileManager("ADSP-BF537");
pMgr->Save("H:\\Test\\adsp-bf537.core");

set app = CreateObject("VisualDSP.ADspApplication")

set cfs = app.PluginList.Item("Core File Support").Open()

set mgr = cfs.CoreFileManager("ADSP-BF537")
mgr.Save("H:\Test\adsp-bf537.core")

IADspApplicationPtr pApp( "VisualDSP.ADspApplication" );
IADspCoreFilePluginPtr pCfsPlugin = pApp->PluginList->GetItem("Core File Support")->Open();
IADspCoreFileManagerPtr pMgr = pCfsPlugin->CoreFileManager("ADSP-BF537");
IADspCoreFileMemoryBlockPtr pMemBlock( "CoreFileSupport.ADspCoreFileMemoryBlock" );
pMemBlock->StartAddress = 0xffa10000;
pMemBlock->EndAddress = 0xffa13fff;
pMemBlock->Name = "my code";
pMemBlock->MemoryType = "BLACKFIN Memory";
pMgr->MemoryBlockList->Add(pMemBlock);
pMgr->Save("H:\\Test\\adsp-bf537.core");

set app = CreateObject("VisualDSP.ADspApplication")

set cfs = app.PluginList.Item("Core File Support").Open()

set mgr = cfs.CoreFileManager("ADSP-BF537")

set mem_block = CreateObject("CoreFileSupport.ADspCoreFileMemoryBlock")
mem_block.StartAddress = &hffa10000
mem_block.EndAddress = &hffa13fff
mem_block.Name = "my code"
mem_block.MemoryType = "BLACKFIN Memory"

set mem_list = mgr.MemoryBlockList
mem_list.Add(mem_block)
mgr.Save("H:\Test\adsp-bf537.core")

IADspApplicationPtr pApp;
pApp.CreateInstance( "VisualDSP.ADspApplication" );

try
{
   IADspDebugSessionPtr pSession = pApp->CreateSession("My Session Name",
                                                       "ADSP-2106x Family Simulator",
                                                       "ADSP-2106x Simulator",
                                                       "ADSP-21065L" );
}

catch ( _com_error err )
{
   pApp->PrintText( tabConsole, "CreateSession failed" );
}

Dim app As Application

Dim session As ADspDebugSession

Set app = CreateObject( "VisualDSP.ADspApplication" )

On Error Resume Next

Set session = app.CreateSession( "My Session Name", _
                                 "ADSP-2106x Family Simulator", _
                                 "ADSP-2106x Simulator", _
                                 "ADSP-21065L" )

If (session Is Nothing) Then
   app.PrintText tabConsole, "CreateSession failed"

End If

IADspApplicationPtr pApp;
pApp.CreateInstance( "VisualDSP.ADspApplication" );

// Получение списка установленных в целей отладки (debug target):
IADspDebugTargetListPtr pDebugTargetList = pApp->DebugTargetList;

// Проход по списку целей отладки и отображение имени каждого:

for ( long i = 0; i < pDebugTargetList->Count; i++ )
{
   IADspDebugTargetPtr pDebugTarget = pDebugTargetList->GetItem( i );
   pApp->PrintText( tabConsole, pDebugTarget->Name );
}

Dim app As Application

Dim debug_target_list As ADspDebugTargetList

Dim debug_target As ADspDebugTarget

Set app = CreateObject( "VisualDSP.ADspApplication" )

Rem Получение списка установленных в целей отладки (debug target):

Set debug_target_list = app.DebugTargetList

Rem Проход по списку целей отладки и отображение имени каждого:

For Each debug_target In debug_target_list
   app.PrintText tabConsole, debug_target.Name

Next

IADspApplicationPtr pApp;

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspDocumentsPtr pDocumentList = pApp->Documents;

for ( long i = 0; i < pDocumentList->Count; i++ )
{
   IADspDocumentPtr pDocument = pDocumentList->GetItem( i );
   pApp->PrintText( tabConsole, pDocument->Name );
}

Dim app As Application

Dim document_list As ADspDocuments

Dim document As ADspDocument

Set app = CreateObject( "VisualDSP.ADspApplication" )

Set document_list = app.Documents

For Each document In document_list
    app.PrintText tabConsole, document.Name

Next

// test.cpp: определяет точку входа в консольное приложение.

//

// Как использовать: передайте начальный адрес для дампа памяти, и количество

// ячеек в формате HEX (без префикса 0x)

#include "stdafx.h"

#define _SAFP_

#ifdef _SAFP_

 #import "C:\Program Files\Analog Devices\VisualDSP 4.5\System\WmSAFP.dll" named_guids no_namespace

#else

 #import "C:\Program Files\Analog Devices\Visualdsp 4.5\System\WmFlashProgrammer.dll" named_guids no_namespace

#endif

#define Driver _T("C:\\Program Files\\Analog Devices\\VisualDSP 4.5\\Blackfin\\Examples\\ADSP-BF537 EZ-Kit Lite

   \\Flash Programmer\\BF537EzFlashDriver.dxe")

#define Ldr _T("C:\\Program Files\\Analog Devices\\VisualDSP 4.5\\Blackfin\\Examples\\ADSP-BF537 EZ-Kit Lite

   \\Power_On_Self_Test\\1000320_AA0188-2004_M29W320DB_U24.ldr")

#define Config _T("C:\\Program Files\\Analog Devices\\VisualDSP 4.5\\BF537_SAFP_config.ini")

int _tmain(int argc, _TCHAR* argv[])
{
   // Инициализация библиотек COM:
   CoInitialize( NULL );

   USES_CONVERSION;

   _bstr_t bstrDriverPath = Driver;
   _bstr_t bstrLdrFile = Ldr;
   _bstr_t bstrConfigFile = Config;
   int VerifyWhileWriting = 0x1;
   unsigned long ulBlock66Start = 0x3F0000;
   unsigned short sMAC_Address[3];// Mac address values
   long lCount = 0x1;
   short sStride = 0x1;

   // Назначение MAC-адреса:
   sMAC_Address[0] = 0xE000;
   sMAC_Address[1] = 0xFE22;
   sMAC_Address[2] = 0x3412;

#ifdef _SAFP_
   IADspSAFPPtr pFlashProg("VisualDSP.ADspSAFP");

   // Установка файла конфигурации:
   pFlashProg->put_ConfigFile(bstrConfigFile);

#else
   IADspApplicationPtr pApp("VisualDSP.ADspApplication");
   IADspPluginPtr pFlashPlugin = pApp->PluginList->GetItem("Flash Programmer");
   IADspFlashProgrammerPtr pFlashProg = pFlashPlugin->Open();

#endif

   // Загрузка драйвера:
   printf("Start: Loading the flash programmer driver...\n");
   HRESULT hr = pFlashProg->LoadDriver(bstrDriverPath.GetBSTR());
   if( hr != S_OK )
   {
      printf("Failed Loading Driver");
      return 1;
   }
   printf("Done: Loading the flash programmer driver...\n\n");

   // Загрузка файла в формате Intel Hex:
   printf("Start: Loading POST ldr file...\n");
   hr = pFlashProg->LoadFile(bstrLdrFile.GetBSTR(), formatIntelHex, VerifyWhileWriting, eraseAffected, 0x0 );
   if( hr != S_OK )
   {
      printf("Failed Loading Ldr file.");
      return 1;
   }
   printf("Done: Loading POST ldr file...\n\n");

   printf("Start: Comparing POST ldr file to the flash contents...\n");
   hr = pFlashProg->CompareFlashWithFile(bstrLdrFile.GetBSTR(), formatIntelHex, 0x0);
   if( hr != S_OK )
   {
      printf("Ldr file did not match the contents of flash.");
      return 1;
   }
   printf("Done: Comparing POST ldr file to the flash contents...\n\n");

   try
   {
      // Стирание блока с MAC-адресом:
      printf("Start: Erasing block that contains the MAC address...\n");
      hr = pFlashProg->EraseBlock(70);
      if( hr != S_OK )
      {
         printf("Failed erasing sector.");
         return 1;
      }
      printf("End: Erasing block that contains the MAC address...\n\n");
   }
   catch(...)
   {
      printf("Make sure the sector number is correct and not write protected.\n");
      return -1;
   }

   // Запись нашего MAC-адреса:
   printf("Start: Writing MAC address...\n");
   pFlashProg->FillFlash( ulBlock66Start, lCount, sStride, sMAC_Address[0] );
   if( hr != S_OK )
   {
      printf("Failed filling flash.");
      return 1;
   }
   pFlashProg->FillFlash( (ulBlock66Start + 2), lCount, sStride, sMAC_Address[1] );
   if( hr != S_OK )
   {
      printf("Failed filling flash.");
      return 1;
   }
   pFlashProg->FillFlash( (ulBlock66Start + 4), lCount, sStride, sMAC_Address[2] );
   if( hr != S_OK )
   {
      printf("Failed filling flash.");
      return 1;
   }
   printf("End: Writing MAC address...\n");

#ifndef _SAFP_
   pFlashPlugin->Close(pFlashProg);

#endif

   printf("Done.\n");

   return 0;
}

'//////////////////////////////////////////////////////////////////////////////

'//   Основное приложение

'//////////////////////////////////////////////////////////////////////////////

Const SAFP = 1

Const CONFIG_FILE = "C:\\Program Files\\Analog Devices\\VisualDSP 4.5\\BF537_SAFP_config.ini"

Const DRIVER_FILE = "C:\\Program Files\\Analog Devices\\VisualDSP 4.5\\Blackfin\\Examples

   \\ADSP-BF537 EZ-Kit Lite\\Flash Programmer\\BF537EzFlashDriver.dxe"

Const LDR_FILE = "C:\\Program Files\\Analog Devices\\VisualDSP 4.5\\Blackfin\\Examples

   \\ADSP-BF537 EZ-Kit Lite\\Power_On_Self_Test\\1000320_AA0188-2004_M29W320DB_U24.ldr"

Dim FileFormat

Dim VerifyWhileWriting

Dim EraseOption

Dim StartAddress

FileFormat = 0          ' формат Intel HEX
VerifyWhileWriting = 1  ' проверить память после записи
EraseOption = 0         ' стирать только задействованные сектора памяти
StartAddress = 0        ' этот параметр игнорируется для Intel HEX

if SAFP Then
   Set pFlash = CreateObject("VisualDSP.ADspSAFP")

   ' Установка файла конфигурации:
   wscript.Echo "Setting config file..."
   pFlash.ConfigFile = CONFIG_FILE

Else
   Set app = CreateObject("VisualDSP.ADspApplication")
   Set plugin = app.PluginList.Item("Flash Programmer")
   Set pFlash = plugin.Open()

End If

' Загрузка драйвера:
wscript.Echo "Loading driver..."
pFlash.LoadDriver DRIVER_FILE

' Стирание блока:
wscript.Echo "Erasing Block 0..."
pFlash.EraseBlock 0

' Загрузка ldr-файла
wscript.Echo "Load the LDR file..."
pFlash.LoadFile LDR_FILE, FileFormat, VerifyWhileWriting, EraseOption, StartAddress

if SAFP = 0 Then
   plugin.Close pFlash

End If

wscript.Echo "Done."

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

// Основное приложение

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

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

// Определение переменных

var SAFP = 1;

// Установка пути до файла конфигурации, драйвера и LDR-файла

var ConfigFile = "C:\\Program Files\\Analog Devices\\VisualDSP 4.5\\BF537_SAFP_config.ini";

var DriverFile = "C:\\Program Files\\Analog Devices\\VisualDSP 4.5\\Blackfin\\Examples

   \\ADSP-BF537 EZ-Kit Lite\\Flash Programmer\\BF537EzFlashDriver.dxe";

var LdrFile = "C:\\Program Files\\Analog Devices\\VisualDSP 4.5\\Blackfin\\Examples

   \\ADSP-BF537 EZ-Kit Lite\\Power_On_Self_Test\\1000320_AA0188-2004_M29W320DB_U24.ldr";

var FileFormat = 0;           // формат Intel HEX

var VerifyWhileWriting = 1;   // выполнить проверку после записи

var EraseOption = 0;          // стирать только задействованные сектора

var StartAddress = 0;         // этот параметр игнорируется для Intel HEX

if( SAFP )
{
   // Получить объект SAFP
   var pFlash = new ActiveXObject( "VisualDSP.ADspSAFP" );
   // Установить файл конфигурации:
   WScript.Echo("Setting config file...");
   pFlash.ConfigFile = ConfigFile;
}

else
{
   // Получить объект VDSP:
   var app = new ActiveXObject( "VisualDSP.ADspApplication" );
   var plugin = app.PluginList.Item("Flash Programmer");
   var pFlash = plugin.Open();
}

// Загрузить драйвер:
WScript.Echo("Loading driver...");
pFlash.LoadDriver(DriverFile);

// Стереть первый блок:
WScript.Echo("Erasing sector 0...");
pFlash.EraseBlock(0);

// Загрузка LDR-файла:
WScript.Echo("Loading the LDR file...");
pFlash.LoadFile(LdrFile, FileFormat, VerifyWhileWriting, EraseOption, StartAddress);

if( !SAFP )
{
   plugin.Close(pFlash);
}

WScript.Echo("Done.");

import win32com.client

#/////////////////////////////////////////////////////////////////////////////

#// def main()

#/////////////////////////////////////////////////////////////////////////////

if __name__ == '__main__':
   SAFP = 1

MacAddressBlock = 66                      # 66 для части DB и 70 для части EB
bEraseAll = 0                             # 0 - стереть сектор, 1 - стереть все
MAC_Address = [ 0xE000, 0xFE22, 0x3412 ]  # значение MAC-адреса
DriverPath = "C:\\Program Files\\Analog Devices\\VisualDSP 4.5\\Blackfin\\Examples

   \\ADSP-BF537 EZ-Kit Lite\\Flash Programmer\\BF537EzFlashDriver.dxe"
LdrPath = "C:\\Program Files\\Analog Devices\\VisualDSP 4.5\\Blackfin\\Examples

   \\ADSP-BF537 EZ-Kit Lite\\Power_On_Self_Test\\1000320_AA0188-2004_M29W320DB_U24.ldr"
ConfigFile = "C:\\Program Files\\Analog Devices\\VisualDSP 4.5\\BF537_SAFP_config.ini"

# Параметры для программирования файла
EraseOption = 0x0
FileFormat = 0x0
VerifyWhileWriting = 0x1

if ( SAFP == 1 ):
   pFlash = win32com.client.Dispatch("VisualDSP.ADspSAFP")

   ####
   # Первое, что всегда надо сделать: установить наш файл конфигурации
   ####
   print 'Setting config File.'
   pFlash.ConfigFile = ConfigFile

else:
   app = win32com.client.Dispatch("VisualDSP.ADspApplication")
   plugin = app.PluginList.Item("Flash Programmer")
   pFlash = plugin.Open()

####

# Загрузка драйвера программатора (flash programmer driver)

####

print 'Loading flash driver.'
pFlash.LoadDriver( DriverPath )

####

# Выполнить стирание:

####

if ( bEraseAll == 1 ):
   print 'Erase all of flash.'
   pFlash.EraseAll()

else:
   print 'Erase block 0'
   pFlash.EraseBlock( 0 )

####

# Запись нашего файла во flash:

####

print 'Loading file to flash'
pFlash.LoadFile( LdrPath, FileFormat, VerifyWhileWriting, EraseOption, 0 )

####

# Сравнение нашего файла с содержимым flash:

####

print 'Comparing file with flash'
pFlash.CompareFlashWithFile( LdrPath, FileFormat, 0 )

####

# Теперь запрограммируем MAC-адрес:

####

print 'Erase sector containing the MAC Address'
pFlash.EraseBlock( 66 )

print 'Write our MAC address to flash'
pFlash.FillFlash( 0x3F0000, 1, 1, MAC_Address[0] )
pFlash.FillFlash( 0x3F0002, 1, 1, MAC_Address[1] )
pFlash.FillFlash( 0x3F0004, 1, 1, MAC_Address[2] )

####

# Команда, отправляемая здесь, должна вызвать сброс:

####

print 'Send a custom command'
pFlash.SendCustom( 2 )

if ( SAFP == 0 ):
   plugin.Close( pFlash )

print 'Done'

USES_CONVERSION;

TCHAR szText[1024];
IADspApplicationPtr pApp( "VisualDSP.ADspApplication" );
IADspProcessorPtr pProc = pApp->ActiveSession->ActiveProcessor;
IADspMemoryTypePtr pMem = pProc->MemoryTypeList->GetItem( long(0) );
IADspFunctionListPtr pList = pMem->FunctionList;

for( long i=0; i < pList->Count; i++ )
{
   IADspFunctionPtr pFunction = pList->GetItem(i);
   sprintf( szText,
            "\n  Function Name: %s\n"
            "       FileName: %s(%d)\n"
            " Function Start: 0x%08x\n"
            "     Body Start: 0x%08x\n"
            "       Body End: 0x%08x\n"
            "   Function End: 0x%08x\n"
            "    Memory Type: %s",
            OLE2A(pFunction->Name),
            OLE2A(pFunction->FileName),
            pFunction>Line,
            pFunction>StartOfFunction,
            pFunction>StartOfBody,
            pFunction>EndOfBody,
            pFunction>EndOfFunction,
            OLE2A(pFunction->MemoryType->Name) );

   pApp>PrintText( tabConsole, szText );
}

Dim app As Application

Dim mem As ADspMemoryType

Dim func As ADspFunction

Set app = CreateObject("VisualDSP.ADspApplication")

Set mem = app.ActiveSession.ActiveProcessor.MemoryTypeList(0)

For Each func In mem.FunctionList
   app.PrintText tabConsole, vbCrLf & "   Function Name: " & func.Name
   app.PrintText tabConsole, "        FileName: " & func.FileName & "(" & str(func.Line) & ")"
   app.PrintText tabConsole, "  Function Start: " & Hex(func.StartOfFunction)
   app.PrintText tabConsole, "      Body Start: " & Hex(func.StartOfBody)
   app.PrintText tabConsole, "        Body End: " & Hex(func.EndOfFunction)
   app.PrintText tabConsole, "    Function End: " & Hex(func.EndOfBody)
   app.PrintText tabConsole, "     Memory Type: " & func.MemoryType.Name

Next

IADspApplicationPtr pApp;

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspDebugSessionPtr pSession = pApp->ActiveSession;
IADspProcessorPtr pProcessor = pSession->ProcessorList->GetItem( CComVariant( 0 ) );
IADspHardwareStackListPtr pHardwareStackList = pProcessor->HardwareStackList;

if ( NULL == pHardwareStackList )
{
   pApp->PrintText( tabConsole, "Target does not support hardware stacks" );
}

else
{
   try
   {
      IADspHardwareStackPtr pHardwareStack = pHardwareStackList->GetItem( "PC Stack" );
      if ( 0 == pHardwareStack->StackPointer )
      {
         pApp->PrintText( tabConsole, "PC Stack is empty" );
      }
      else
      {
         IADspValueListPtr pValueList = pHardwareStack->GetStack();
         for ( long i = 0; i < pHardwareStack->StackPointer; i++ )
         {
            IADspValuePtr pValue = pValueList->GetItem( i );
            pApp->PrintText( tabConsole, pValue->ToString( "Hexadecimal" ) );
         }
      }
   }
   catch ( _com_error err )
   {
      pApp->PrintText( tabConsole, "Processor doesn't have a stack named \"PC Stack\"" );
   }
}

   Dim app As Application
   Dim session As ADspDebugSession
   Dim processor As ADspProcessor
   Dim hardware_stack_list As ADspHardwareStackList
   Dim hardware_stack As ADspHardwareStack
   Dim value_list As ADspValueList
   Dim value As ADspValue

   Set app = CreateObject( "VisualDSP.ADspApplication" )
   Set session = app.ActiveSession
   Set processor = session.ProcessorList( 0 )
   Set hardware_stack_list = processor.HardwareStackList

   If (hardware_stack_list Is Nothing) Then
      app.PrintText tabConsole, "Target does not support hardware stacks"
   Else
      On Error GoTo GetItemFailed
      Set hardware_stack = hardware_stack_list( "PC Stack" )
      If ( hardware_stack.StackPointer = 0 ) Then
         app.PrintText tabConsole, "PC Stack is empty"
      Else
         Set value_list = hardware_stack.GetStack
         For i = 0 To hardware_stack.StackPointer - 1
            Set value = value_list( i )
            app.PrintText tabConsole, value.ToString( "Hexadecimal" )
         Next
      End If
   End If
   Exit Sub

GetItemFailed:

   app.PrintText tabConsole, "Processor doesn't have a stack named ""PC Stack"""

IADspApplicationPtr pApp;
TCHAR szBuffer[128];

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspDebugSessionPtr pSession = pApp->ActiveSession;
IADspProcessorPtr pProcessor = pSession->ProcessorList->GetItem( CComVariant( 0 ) );
IADspHardwareStackListPtr pHardwareStackList = pProcessor->HardwareStackList;

if ( NULL == pHardwareStackList )
{
   pApp->PrintText( tabConsole, "Target does not support hardware stacks" );
}

else
{
   for ( long i = 0; i < pHardwareStackList->Count; i++ )
   {
      IADspHardwareStackPtr pHardwareStack = pHardwareStackList->GetItem( i );
      sprintf( szBuffer, "Name = %s  Width = %ld  Depth = %ld",
               (char *) pHardwareStack->Name,
               pHardwareStack->Width, pHardwareStack->Depth );
      pApp->PrintText( tabConsole, szBuffer );
   }
}

Dim app As Application

Dim session As ADspDebugSession

Dim hardware_stack_list As ADspHardwareStackList

Dim hardware_stack As ADspHardwareStack

Dim processor As ADspProcessor

Set app = CreateObject( "VisualDSP.ADspApplication" )

Set session = app.ActiveSession

Set processor = session.ProcessorList( 0 )

Set hardware_stack_list = processor.HardwareStackList

If (hardware_stack_list Is Nothing) Then
   app.PrintText tabConsole, "Target does not support hardware stacks"

Else
   For Each hardware_stack In hardware_stack_list app.PrintText tabConsole, _
      "Name = " + hardware_stack.Name + _
      "  Width = " + CStr( hardware_stack.Width ) + _
      "  Depth = " + CStr(hardware_stack.Depth)
    Next

End If

try
{
   IADspApplicationPtr pApp("VisualDSP.ADspApplication");

   pApp->Interactive = FALSE;

   IADspPluginPtr pImageViewerPlugin = pApp->PluginList->GetItem("ImageViewer");

   IADspImageViewerPtr pImageViewer = pImageViewerPlugin->Open();

   pImageViewer->SourceLocation = sourceLocationFile;
   pImageViewer->WriteStream = FALSE;

   CComVariant var = "Blackfin Memory";
   pImageViewer->put_MemoryType(var);

   pImageViewer->StartAddress = "0xF0000000";

   pImageViewer->LoadImageFile("C:\\test.bmp");

   pApp.Release();
}

catch( _com_error err )
{
   AfxMessageBox("test failed");
}

Set App = CreateObject("VisualDSP.ADspApplication")
App.Interactive = False

Set ImageViewerPlugin = App.PluginList("ImageViewer")

Set ImageViewer = ImageViewerPlugin.Open()

ImageViewer.SourceLocation = sourceLocationFile
ImageViewer.WriteStream = False
ImageViewer.MemoryType = "Blackfin Memory"
ImageViewer.StartAddress = "0xF0000000"
ImageViewer.LoadImageFile ("C:\\test.bmp")

IADspApplicationPtr pApp;
TCHAR szBuffer[128];

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspDebugSessionPtr pSession = pApp->ActiveSession;
IADspProcessorPtr pProcessor = pSession->ProcessorList->GetItem( CComVariant( 0 ) );
IADspInterruptListPtr pInterruptList = pProcessor->InterruptList;

for ( long i = 0; i < pInterruptList->Count; i++ )
{
   IADspInterruptPtr pInterrupt = pInterruptList->GetItem( i );
   sprintf(szBuffer, "Interrupt Name=%s Enabled=%d Min Cycles=%ld Max Cycles=%ld Delay Cycles=%ld",
           (char *)pInterrupt->Name, pInterrupt->Enabled, pInterrupt->MinCycles,
           pInterrupt->MaxCycles, pInterrupt->DelayCycles );
   pApp->PrintText( tabConsole, szBuffer );
}

Dim app As Application

Dim session As ADspDebugSession

Dim interrupt_list As ADspInterruptList

Dim interrupt As ADspInterrupt

Dim processor As ADspProcessor

Set app = CreateObject( "VisualDSP.ADspApplication" )

Set session = app.ActiveSession

Set processor = session.ProcessorList( 0 )

Set interrupt_list = processor.InterruptList

For Each interrupt In interrupt_list
   app.PrintText tabConsole, _
      "Interrupt Name = " + interrupt.Name + _
      "  Enabled = " + CStr( interrupt.Enabled ) + _
      "  Min Cycles = " + CStr( interrupt.MinCycles ) + _
      "  Max Cycles = " + CStr( interrupt.MaxCycles ) + _
      "  Delay Cycles = " + CStr( interrupt.DelayCycles )

Next

IADspApplicationPtr pApp;
TCHAR szBuffer[256];

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspDebugSessionPtr pSession = pApp->ActiveSession;
IADspProcessorPtr pProcessor = pSession->ProcessorList->GetItem( CComVariant( 0 ) );
IADspMemorySegmentListPtr pMemorySegmentList = pProcessor->MemorySegmentList;

for ( long i = 0; i < pMemorySegmentList->Count; i++ )
{
   IADspMemorySegmentPtr pMemorySegment = pMemorySegmentList->GetItem( i );
   sprintf( szBuffer, "Name=%s MemoryType=%s StartAddress=0x%lx EndAddress=0x%lx AccessType=%d",
            (char *) pMemorySegment->Name,
            (char *) pMemorySegment->MemoryType->Name,
            pMemorySegment->StartAddress, pMemorySegment->EndAddress,
            pMemorySegment->AccessType );
   pApp->PrintText( tabConsole, szBuffer );
}

Dim app As Application

Dim session As ADspDebugSession

Dim memory_segment_list As ADspMemorySegmentList

Dim memory_segment As ADspMemorySegment

Dim processor As ADspProcessor

Set app = CreateObject( "VisualDSP.ADspApplication" )

Set session = app.ActiveSession

Set processor = session.ProcessorList( 0 )

Set memory_segment_list = processor.MemorySegmentList

For Each memory_segment In memory_segment_list
   app.PrintText tabConsole, _
   "Name = " + memory_segment.Name + _
   "  Memory Type = " + memory_segment.MemoryType.Name + _
   "  Start Address = 0x" + Hex( memory_segment.StartAddress ) + _
   "  End Address = 0x" + Hex( memory_segment.EndAddress ) + _
   "  Access Type = " + CStr(memory_segment.AccessType)

Next

IADspApplicationPtr pApp;

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspDebugSessionPtr pSession = pApp->ActiveSession;
IADspProcessorPtr pProcessor = pSession->ProcessorList->GetItem( CComVariant( 0 ) );
IADspMemoryTypeListPtr pMemoryTypeList = pProcessor->MemoryTypeList;

try
{
   IADspMemoryTypePtr pMemoryType = pMemoryTypeList->GetItem( "Data(DM) Memory" );
   try
   {
      IADspValueListPtr pValueList=pMemoryType->GetMemory(0x30000, // начальный адрес
                                                          10,      // количество ячеек
                                                          1 );     // шаг
      for ( long i = 0; i < pValueList->Count; i++ )
      {
         IADspValuePtr pValue = pValueList->GetItem( i );
         pApp->PrintText( tabConsole, pValue->ToString( "Hexadecimal" ) );
      }
   }
   catch ( _com_error err )
   {
      pApp->PrintText( tabConsole, "GetMemory failed" );
   }
}

catch ( _com_error err )
{
   pApp->PrintText( tabConsole, "Processor doesn't have memory named \"Data(DM) Memory\"" );
}

   Dim app As Application
   Dim session As ADspDebugSession
   Dim processor As ADspProcessor
   Dim memory_type_list As ADspMemoryTypeList
   Dim memory_type As ADspMemoryType
   Dim value_list As ADspValueList
   Dim value As ADspValue

   Set app = CreateObject( "VisualDSP.ADspApplication" )
   Set session = app.ActiveSession
   Set processor = session.ProcessorList( 0 )
   Set memory_type_list = processor.MemoryTypeList

   On Error GoTo GetItemFailed
   Set memory_type = memory_type_list( "Data(DM) Memory" )

   On Error GoTo GetMemoryFailed
   Set value_list = memory_type.GetMemory( &h30000, 10, 1 )
   For Each value In value_list
       app.PrintText tabConsole, value.ToString( "Hexadecimal" )
   Next

   Exit Sub

GetItemFailed:
   app.PrintText tabConsole, "Processor doesn't have memory named ""Data(DM) Memory""
   Exit Sub

GetMemoryFailed:
   app.PrintText tabConsole, "GetMemory failed"

IADspApplicationPtr pApp;
TCHAR szBuffer[128];

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspDebugSessionPtr pSession = pApp->ActiveSession;
IADspProcessorPtr pProcessor = pSession->ProcessorList->GetItem( CComVariant( 0 ) );
IADspMemoryTypeListPtr pMemoryTypeList = pProcessor->MemoryTypeList;

for ( long i = 0; i < pMemoryTypeList->Count; i++ )
{
   IADspMemoryTypePtr pMemoryType = pMemoryTypeList->GetItem( i );
   sprintf( szBuffer, "Name = %s  Width = %ld",
           (char *) pMemoryType->Name, pMemoryType->Width );
   pApp->PrintText( tabConsole, szBuffer );
}

Dim app As Application

Dim session As ADspDebugSession

Dim memory_type_list As ADspMemoryTypeList

Dim memory_type As ADspMemoryType

Dim processor As ADspProcessor

Set app = CreateObject( "VisualDSP.ADspApplication" )

Set session = app.ActiveSession

Set processor = session.ProcessorList( 0 )

Set memory_type_list = processor.MemoryTypeList

For Each memory_type In memory_type_list
   app.PrintText tabConsole, "Name = " + memory_type.Name + _
                             "  Width = " + CStr( memory_type.Width )

Next

IADspApplicationPtr pApp;

short menuid;

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspMenuManagerPtr pMenuManager = pApp->MenuManager;

menuid=pMenuManager->AddMenuTail("&Tools:&My Menu Item",
                                 "This is a custom menu item.");

Dim app As Application

Dim WithEvents menumanager As ADspMenuManager

Dim menuid As Integer

Set app = CreateObject( "VisualDSP.ADspApplication" )

Set menumanager = app.MenuManager

menuid = menumanager.AddMenuTail( "&Tools:&My Menu Item", _
                                  "This is a custom menu item." )

ADspApplicationPtr pApp;

pApp.CreateInstance( "VisualDSP.ADspApplication" );

try
{
   IADspMPGroupPtr pMPGroup;
   IADspDebugSessionPtr pSession = pApp->ActiveSession;
   try
   {
      IADspMPGroupListPtr pMPGroupList = pSession->MPGroupList;
      if ( NULL == pMPGroupList)
      {
         pApp->PrintText( tabConsole, "Current session is not multiprocessor!" );
      }
      else
      {
         pMPGroup = pMPGroupList->CreateMPGroup( "My Group Name" );
         // Добавление всех доступных процессоров в группу:
         for (long i = 0; i < pSession->ProcessorList->Count; i++ )
         {
            pMPGroup->AddProcToGroup( CComVariant( i ) );
         }
         pMPGroup->MPStepAsm();
         pMPGroupList->RemoveGroup( "My Group Name" );
      }
   }
   catch ( _com_error err )
   {
      pApp->PrintText( tabConsole, "CreateMPGroup failed" );
   }
}

catch ( _com_error err )
{
    pApp->PrintText( tabConsole, "CreateMPSession failed" );
}

   Dim app As Application
   Dim session As ADspDebugSession
   Dim group As ADspMPGroup
   Dim group_list As ADspMPGroupList
   Dim i As Integer

   Set app = CreateObject( "VisualDSP.ADspApplication" )

   On Error Resume Next
   Set session = app.ActiveSession

   If (session Is Nothing) Then
      app.PrintText tabConsole, "CreateMPSession failed"
   Else
      Set group_list = session.MPGroupList
      If (group_list Is Nothing) Then
         app.PrintText tabConsole, "Current session is not multiprocessor!"
      Else
         On Error GoTo CreateMPGroupFailed
         Set group = group_list.CreateMPGroup( "My Group Name" )
         Rem добавление всех доступных процессоров в группу
         For i=0 To session.ProcessorList.Count-1
            group.AddProcToGroup i
         Next
         group.MPStepAsm
         group_list.RemoveGroup "My Group Name"
      End If
   End If

   Exit Sub

CreateMPGroupFailed:
   app.PrintText tabConsole, "CreateMPGroup failed"

IADspApplicationPtr pApp;

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspDebugSessionPtr pSession = pApp->ActiveSession;
IADspMPGroupListPtr pMPGroupList = pSession->MPGroupList;

if ( NULL == pMPGroupList ) {
    pApp->PrintText( tabConsole, "Current session is not multiprocessor" );
}
else {
    for ( long i = 0; i < pMPGroupList->Count; i++ ) {
        IADspMPGroupPtr pMPGroup = pMPGroupList->GetItem( i );
        pApp->PrintText( tabConsole, pMPGroup->Name );
    }
}

Dim app As Application
Dim session As ADspDebugSession
Dim mpgroup_list As ADspMPGroupList
Dim mpgroup As ADspMPGroup

Set app = CreateObject( "VisualDSP.ADspApplication" )
Set session = app.ActiveSession
Set mpgroup_list = session.MPGroupList
If (mpgroup_list Is Nothing) Then
    app.PrintText tabConsole, "Current session is not multiprocessor"

Else
   For Each mpgroup In mpgroup_list
      app.PrintText tabConsole, mpgroup.Name
   Next
End If

IADspApplicationPtr pApp;
TCHAR szBuffer[256];

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspSessionListPtr pSessionList = pApp->SessionList;

for ( long i = 0; i < pSessionList->Count; i++ )
{
   IADspSessionPtr pSession = pSessionList->GetItem( i );
   pApp->PrintText( tabConsole, pSession->Name );
   IADspMPGroupInfoListPtr pMPGroupInfoList = pSession->MPGroupInfoList;
   if ( pMPGroupInfoList != NULL)
   {
      for ( long j = 0; j < pMPGroupInfoList->Count; j++ )
      {
         IADspMPGroupInfoPtr pMPGroupInfo = pMPGroupInfoList->GetItem( j );
         sprintf( szBuffer, "    MP Group Name = %s", (char *) pMPGroupInfo->Name );
         pApp->PrintText( tabConsole, szBuffer );
      }
   }
}

Dim app As Application
Dim session_list As ADspSessionList
Dim session As ADspSession

Set app = CreateObject( "VisualDSP.ADspApplication" )
Set session_list = app.SessionList

For Each session In session_list
   app.PrintText tabConsole, session.Name
   If ( not session.MPGroupInfoList is Nothing ) Then
      For Each mpgroupinfo In session.MPGroupInfoList
         app.PrintText tabConsole, "    MP Group Name = " + mpgroupinfo.Name
      Next
   End if
Next

IADspApplicationPtr pApp;
IADspOutputWindowPtr pOutputWindow;

pApp.CreateInstance( "VisualDSP.ADspApplication" );
pOutputWindow = pApp->OutputWindow;
pOutputWindow->PrintText( "Hello World!", textTypeConsoleNormal );

Dim app As Application
Dim outputWindow As ADspOutputWindow

Set app = CreateObject( "VisualDSP.ADspApplication" )
Set outputWindow = app.OutputWindow
outputWindow.PrintText "Hello World!", textTypeConsoleNormal

IADspApplicationPtr pApp( "VisualDSP.ADspApplication" );
IADspProcessorPtr pProcessor = pApp->ActiveSession->ActiveProcessor;
IADspPgoPluginPtr pPgoPlugin = pApp->PluginList->GetItem("PGO Engine")->Open();

// Получить менеджер PGO для активного процессора:
IADspPgoManagerPtr pPgoMgr = pPgoPlugin->PgoManager( (LPDISPATCH)pProcessor );

// Загрузить приложение, которое было собрано с опцией -pguide:
pProcessor->LoadProgram( "MyApp.dxe" );

// Установка выходного файла:
pPgoMgr->OutputFileName = "MyApp.pgo";

// Запуск сбора данных:
pPgoMgr->Enabled = TRUE;

// Запуск приложения, чтобы сделать сбор данных:
pProcessor->Run( TRUE );

// Запрет сбора данных (и сброс их в выходной файл):
pPgoMgr->Enabled = FALSE;

Set app = CreateObject( "VisualDSP.ADspApplication" )
Set proc = app.ActiveSession.ActiveProcessor
Set pgoPlugin = app.PluginList("PGO Engine").Open()

' Получить менеджер PGO для активного процессора:
Set pgoMgr = pgoPlugin.PgoManager( proc )

' Загрузить приложение, которое было собрано с опцией -pguide:
proc.LoadProgram "MyApp.dxe"

' Установка выходного файла:
pgoMgr.OutputFileName = "MyApp.pgo"

' Запуск сбора данных:
pgoMgr.Enabled = True

' Запуск приложения, чтобы сделать сбор данных:
proc.Run True

' Запрет сбора данных (и сброс их в выходной файл):
pgoMgr.Enabled = False

IADspApplicationPtr pApp;
TCHAR szBuffer[128];
pApp.CreateInstance( "VisualDSP.ADspApplication" );

// Получение списка установленных целей отладки (debug target):
IADspDebugTargetListPtr pDebugTargetList = pApp->DebugTargetList;

// Проход по списку целей отладки и получение имени каждой цели:
for ( long i = 0; i < pDebugTargetList->Count; i++ )
{
   IADspDebugTargetPtr pDebugTarget = pDebugTargetList->GetItem( i );
   pApp->PrintText( tabConsole, pDebugTarget->Name );
   // Получение списка платформ цели:
   IADspPlatformListPtr pPlatformList = pDebugTarget->PlatformList;
   // Проход по списку платформ каждой цели и отображение имени
   // каждой платформы:
   for ( long j = 0; j < pPlatformList->Count; j++ )
   {
      IADspPlatformPtr pPlatform = pPlatformList->GetItem( j );
      sprintf( szBuffer, "    Platform Name = %s", (char *) pPlatform->Name );
      pApp->PrintText( tabConsole, szBuffer );
   }
}

Dim app As Application
Dim debug_target_list As ADspDebugTargetList
Dim debug_target As ADspDebugTarget
Dim platform_list As ADspPlatformList
Dim platform As ADspPlatform

Set app = CreateObject( "VisualDSP.ADspApplication" )

Rem Получение списка установленных целей отладки (debug target):
Set debug_target_list = app.DebugTargetList

Rem Проход по списку целей отладки и получение имени каждой цели:
For Each debug_target In debug_target_list
   app.PrintText tabConsole, debug_target.Name
   Rem Получение списка платформ цели:
   Set platform_list = debug_target.PlatformList
   Rem Проход по списку платформ каждой цели и отображение имени
   Rem каждой платформы:
   For Each platform In platform_list
      app.PrintText tabConsole, "    Platform Name = " + platform.Name
   Next
Next

USES_CONVERSION;
TCHAR szText[4096];
IADspApplicationPtr pApp("VisualDSP.ADspApplication");
IADspPluginListPtr pPluginList = pApp->PluginList;

for( long i=0; i < pPluginList->Count; i++ )
{
   IADspPluginPtr pPlugin = pPluginList->GetItem( i );
   sprintf( szText,
            "\n      Plugin Name: %s\n"
            "      Description: %s\n"
            "          Enabled: %d\n"
            "            CLSID: %s\n"
            "MultipleInstances: %d\n"
            "     StartupStyle: %d\n"
            "       WindowType: %d\n"
            "   WindowHelpPath: %s\n"
            "         MenuItem: %s\n"
            "     MenuHelpPath: %s\n"
            "  MenuDescription: %s  ",
            OLE2A(pPlugin->Name),
            OLE2A(pPlugin->Description),
            pPlugin->Enabled,
            OLE2A(pPlugin->CLSID),
            pPlugin->AllowMultipleInstances,
            pPlugin->StartupStyle,
            pPlugin->WindowType,
            OLE2A(pPlugin->WindowHelpPath),
            OLE2A(pPlugin->MenuItem),
            OLE2A(pPlugin->MenuHelpPath),
            OLE2A(pPlugin->MenuDescription) );
   pApp->PrintText( tabConsole, szText );
}

Dim app As Application
Dim plugin As ADspPlugin

Set app = CreateObject("VisualDSP.ADspApplication")

For Each plugin In app.PluginList
   app.PrintText tabConsole, vbCrLf & "      Plugin Name: " & plugin.Name
   app.PrintText tabConsole, "      Description: " & plugin.Description
   app.PrintText tabConsole, "          Enabled: " & plugin.Enabled
   app.PrintText tabConsole, "            CLSID: " & plugin.CLSID
   app.PrintText tabConsole, "MultipleInstances: " & plugin.AllowMultipleInstances
   app.PrintText tabConsole, "     StartupStyle: " & plugin.StartupStyle
   app.PrintText tabConsole, "       WindowType: " & plugin.WindowType
   app.PrintText tabConsole, "   WindowHelpPath: " & plugin.WindowHelpPath
   app.PrintText tabConsole, "         MenuItem: " & plugin.MenuItem
   app.PrintText tabConsole, "     MenuHelpPath: " & plugin.MenuHelpPath
   app.PrintText tabConsole, "  MenuDescription: " & plugin.MenuDescription
Next

IADspApplicationPtr pApp("VisualDSP.ADspApplication");
IADspPluginListPtr pPluginList = pApp->PluginList;

for( long i=0; i < pPluginList->Count; i++ )
{
   IADspPluginPtr pPlugin = pPluginList->GetItem( i );
   pApp->PrintText( tabConsole, pPlugin->Name );
}

Dim app As Application
Dim plugin As ADspPlugin

Set app = CreateObject( "VisualDSP.ADspApplication" )

For Each plugin In app.PluginList
   app.PrintText tabConsole, plugin.Name
Next

IADspApplicationPtr pApp;

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspDebugSessionPtr pSession = pApp->ActiveSession;
IADspProcessorPtr pProcessor = pSession->ProcessorList->GetItem( CComVariant( 0 ) );

try
{
   pProcessor->LoadProgram( "c:\\examples\\test.dxe" );
   pProcessor->Run( TRUE );
}
catch ( _com_error err )
{
   pApp->PrintText( tabConsole, "Failed to load program" );
}

   Dim app As Application
   Dim session As ADspDebugSession
   Dim processor As ADspProcessor

   Set app = CreateObject( "VisualDSP.ADspApplication" )
   Set session = app.ActiveSession
   Set processor = session.ProcessorList( 0 )

   On Error GoTo LoadFailed
   processor.LoadProgram "c:\examples\test.dxe"
   processor.Run True

   Exit Sub

LoadFailed:
   app.PrintText tabConsole, "Failed to load program"

IADspApplicationPtr pApp;
TCHAR szBuffer[128];

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspDebugSessionPtr pSession = pApp->ActiveSession;
IADspProcessorListPtr pProcessorList = pSession->ProcessorList;

for ( long i = 0; i < pProcessorList->Count; i++ )
{
   IADspProcessorPtr pProcessor = pProcessorList->GetItem( i );
   sprintf( szBuffer, "Name = %s  Type = %s",
            (char *) pProcessor->Name,
            (char *) pProcessor->Type );
   pApp->PrintText( tabConsole, szBuffer );
}

Dim app As Application

Dim session As ADspDebugSession

Dim processor_list As ADspProcessorList

Dim processor As ADspProcessor

Set app = CreateObject( "VisualDSP.ADspApplication" )

Set session = app.ActiveSession

Set processor_list = session.ProcessorList

For Each processor In processor_list
   app.PrintText tabConsole, "Name = " + processor.Name + _
                             "  Type = " + processor.Type

Next

IADspApplicationPtr pApp;
TCHAR szBuffer[300];

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspDebugSessionPtr pSession = pApp->ActiveSession;
IADspProcessorPtr pProcessor = pSession->ProcessorList->GetItem( CComVariant( 0 ) );
IADspProfileSessionListPtr pProfileSessionList = pProcessor->ProfileSessionList;

IADspProfileSessionPtr pProfileSession = pProfileSessionList->GetItem( CComVariant( 0 ) );
pProfileSession->MemoryName = pProfileSessionList->MemoryNames->Item(0);

pProfileSession->FilterType = profileEntireMemory;
pProfileSession->DebugSamplesOnly = TRUE;

pProcessor->LoadProgram("C:\\test\\debug\\mytest.dxe");
pProcessor->Run(TRUE);
IADspProfileExecutionUnitListPtr pExecutionUnitList = pProfileSession->ExecutionUnitList;

for( long i = 0; i < pExecutionUnitList->Count; i++ )
{
    IADspProfileExecutionUnitPtr pExecutionUnit = pExecutionUnitList->GetItem(i);
    sprintf(szBuffer, "0x%x,  %d", pExecutionUnit->Address, pExecutionUnit->SampleCount);
    pApp->PrintText( tabConsole, szBuffer );
}

Dim app As Application

Dim session As ADspDebugSession

Dim profile_session_list As ADspProfileSessionList

Dim processor As ADspProcessor

Dim profile_session As ADspProfileSession

Dim execution_unit_list As ADspProfileExecutionUnitList

Dim execution_unit As ADspProfileExecutionUnit

Set app = CreateObject("VisualDSP.ADspApplication")

Set session = app.ActiveSession

Set processor = session.ProcessorList(0)

Set profile_session_list = processor.ProfileSessionList

Set profile_session = profile_session_list(0)

profile_session.MemoryName = profile_session_list.MemoryNames(0)
profile_session.DebugSamplesOnly = True
profile_session.FilterType = profileEntireMemory

processor.LoadProgram ("C:\testlab\generic\test\debug\testsave.dxe")
processor.Run (True)
processor.Run (True)

Set execution_unit_list = profile_session.ExecutionUnitList

For Each execution_unit In execution_unit_list
   app.PrintText tabConsole, "0x" + Hex(execution_unit.Address) + _
                             ",  " + CStr(execution_unit.SampleCount)

Next

IADspApplicationPtr pApp;
TCHAR szBuffer[300];
pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspDebugSessionPtr pSession = pApp->ActiveSession;
IADspProcessorPtr pProcessor = pSession->ProcessorList->GetItem( CComVariant( 0 ) );
IADspProfileSessionListPtr pProfileSessionList = pProcessor->ProfileSessionList;
IADspProfileSessionPtr pProfileSession = pProfileSessionList->GetItem( CComVariant( 0 ) );
pProfileSession->MemoryName = pProfileSessionList->MemoryNames->Item(0);
pProfileSession->FilterType = profileFunctions;
pProfileSession->DebugSamplesOnly = TRUE;
pProcessor->LoadProgram("C:\\test\\debug\\mytest.dxe");
IADspSymbolListPtr pSymbolList = pProcessor->MemoryTypeList->FindSymbol( "main" );
IADspFunctionListPtr pLoadedFunctions = pSymbolList->GetItem(0)->MemoryType->FunctionList;
IADspProfileFunctionListPtr pFunctionList = pProfileSession->FunctionList;

for ( long i = 0; i < pLoadedFunctions->Count; i++ )
{
   IADspFunctionPtr pFunc = pLoadedFunctions->GetItem(i);
   IADspProfileFunctionPtr pProfileFunc;
   pProfileFunc.CreateInstance( "VisualDSP.ADspProfileFunction" );
   pProfileFunc->Name = pFunc->Name;
   pProfileFunc->FileName = pFunc->FileName;
   pFunctionList->Add(pProfileFunc);
}
pProcessor->Run(TRUE);

for ( i = 0; i < pFunctionList->Count; i++)
{
   IADspProfileFunctionPtr pProfileFunc = pFunctionList->GetItem(i);
   BSTR pszTmp = pProfileFunc->Name;
   CString csFuncName = pszTmp;
   ::SysFreeString(pszTmp);
   pszTmp = pProfileFunc->FileName;
   CString csFileName = pszTmp;
   ::SysFreeString(pszTmp);
   sprintf(szBuffer, "\"%s\" in file \"%s\" has sample count %d",
                     csFuncName, csFileName,
                     pProfileFunc->SampleCount);
   pApp->PrintText( tabConsole, szBuffer );
}

Dim app As Application
Dim session As ADspDebugSession
Dim profile_session_list As ADspProfileSessionList
Dim processor As ADspProcessor
Dim profile_session As ADspProfileSession
Dim symbol_list As ADspSymbolList
Dim loaded_functions As ADspFunctionList
Dim func As ADspFunction
Dim function_list As ADspProfileFunctionList
Dim profile_function As ADspProfileFunction

Set app = CreateObject("VisualDSP.ADspApplication")
Set session = app.ActiveSession
Set processor = session.ProcessorList(0)
Set profile_session_list = processor.ProfileSessionList
Set profile_session = profile_session_list(0)
profile_session.MemoryName = profile_session_list.MemoryNames(0)
profile_session.DebugSamplesOnly = True
profile_session.FilterType = profileFunctions
processor.LoadProgram ("C:\testlab\generic\test\debug\testsave.dxe")

Set symbol_list = processor.MemoryTypeList.FindSymbol("main")
Set loaded_functions = symbol_list(0).MemoryType.FunctionList
Set profile_function = New ADspProfileFunction
Set function_list = profile_session.FunctionList

For Each func In loaded_functions
   Set profile_function = New ADspProfileFunction
   profile_function.Name = func.Name
   profile_function.FileName = func.FileName
   function_list.Add profile_function
Next
processor.Run (True)

For Each profile_function In function_list
   app.PrintText tabConsole, 
   """" + profile_function.Name + _
   """" + " in file " + _
   """" + profile_function.FileName + _
   """" + " has sample count " + CStr(profile_function.SampleCount)
Next

IADspApplicationPtr pApp;
TCHAR szBuffer[300];

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspDebugSessionPtr pSession = pApp->ActiveSession;
IADspProcessorPtr pProcessor = pSession->ProcessorList->GetItem( CComVariant( 0 ) );
IADspProfileSessionListPtr pProfileSessionList = pProcessor->ProfileSessionList;

IADspProfileSessionPtr pProfileSession = pProfileSessionList->GetItem( CComVariant( 0 ) );
pProfileSession->MemoryName = pProfileSessionList->MemoryNames->Item(0);

pProfileSession->FilterType = profileRanges;
pProfileSession->DebugSamplesOnly = TRUE;

pProcessor->LoadProgram("C:\\test\\debug\\mytest.dxe");

IADspProfileRangeListPtr pRangeList = pProfileSession->AddressRangeList;

IADspProfileRangePtr pProfileRange;
pProfileRange.CreateInstance( "VisualDSP.ADspProfileRange" );

IADspSymbolListPtr pSymbolList = pProcessor->MemoryTypeList->FindSymbol( "foo" );

long lStart = pSymbolList->GetItem(0)->Address;
pProfileRange->StartAddress = lStart;

pSymbolList = pProcessor->MemoryTypeList->FindSymbol( "main" );
pProfileRange->EndAddress = pSymbolList->GetItem(0)->Address;

pRangeList->Add(pProfileRange);

pProfileRange.CreateInstance( "VisualDSP.ADspProfileRange" );

pProfileRange->StartAddress = lStart;

pSymbolList = pProcessor->MemoryTypeList->FindSymbol( "bar" );
pProfileRange->EndAddress = pSymbolList->GetItem(0)->Address;

pRangeList->Add(pProfileRange);

pProcessor->Run(TRUE);

for (long i = 0; i < pRangeList->Count; i++)
{
   IADspProfileRangePtr pRange = pRangeList->GetItem(i);
   sprintf(szBuffer, "The range starts at 0x%x,  ends at 0x%x,  has sample count %d",
                     pRange->StartAddress, pRange->EndAddress, pRange->SampleCount);
   pApp->PrintText( tabConsole, szBuffer );
}

Dim app As Application

Dim session As ADspDebugSession

Dim profile_session_list As ADspProfileSessionList

Dim processor As ADspProcessor

Dim profile_session As ADspProfileSession

Dim symbol_list As ADspSymbolList

Dim range_list As ADspProfileRangeList

Dim range As ADspProfileRange

Set app = CreateObject("VisualDSP.ADspApplication")

Set session = app.ActiveSession

Set processor = session.ProcessorList(0)

Set profile_session_list = processor.ProfileSessionList

Set profile_session = profile_session_list(0)

profile_session.MemoryName = profile_session_list.MemoryNames(0)
profile_session.DebugSamplesOnly = True
profile_session.FilterType = profileRanges

processor.LoadProgram ("C:\\testlab\\generic\\test\\debug\\testsave.dxe")

Set range_list = profile_session.AddressRangeList

Set range = New ADspProfileRange

Set symbol_list = processor.MemoryTypeList.FindSymbol("foo")

range.StartAddress = symbol_list(0).Address

Set symbol_list = processor.MemoryTypeList.FindSymbol("main")
range.EndAddress = symbol_list(0).Address
range_list.Add range

Set range = New ADspProfileRange

Set symbol_list = processor.MemoryTypeList.FindSymbol("foo")
range.StartAddress = symbol_list(0).Address

Set symbol_list = processor.MemoryTypeList.FindSymbol("bar")
range.EndAddress = symbol_list(0).Address
range_list.Add range

processor.Run (True)

For Each range In range_list
   app.PrintText tabConsole,
      "The range starts at 0x" + Hex(range.StartAddress) + _
      ", ends at 0x" + Hex(range.EndAddress) + _
      ", with sample count " + CStr(range.SampleCount)

Next 

IADspApplicationPtr pApp;
TCHAR szBuffer[300];

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspDebugSessionPtr pSession = pApp->ActiveSession;
IADspProcessorPtr pProcessor = pSession->ProcessorList->GetItem( CComVariant( 0 ) );
IADspProfileSessionListPtr pProfileSessionList = pProcessor->ProfileSessionList;

for ( long i = 0; i < pProfileSessionList->Count; i++ )
{
   IADspProfileSessionPtr pProfileSession = pProfileSessionList->GetItem( i );
   BSTR pszName = pProfileSession->Name;
   CString csName = pszName;

   ::SysFreeString(pszName);

   sprintf( szBuffer, "Profile session \"%s\" is %s",
            csName, pProfileSession->Enabled?"enabled":"disabled");
   pApp->PrintText( tabConsole, szBuffer );
}

Dim app As Application

Dim session As ADspDebugSession

Dim profile_session_list As ADspProfileSessionList

Dim profile_session As ADspProfileSession

Dim processor As ADspProcessor

Dim enabled As String

Set app = CreateObject("VisualDSP.ADspApplication")

Set session = app.ActiveSession

Set processor = session.ProcessorList(0)

Set profile_session_list = processor.ProfileSessionList

For Each profile_session In profile_session_list
    If profile_session.Enabled Then
        enabled = "enabled"
    Else
        enabled = "disabled"
    End If

    app.PrintText tabConsole, "Profile session " + """" + _
                              profile_session.Name + """" + _
                              " is " + enabled

Next

IADspApplicationPtr pApp;

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspDebugSessionPtr pSession = pApp->ActiveSession;
IADspProcessorPtr pProcessor = pSession->ProcessorList->GetItem( CComVariant( 0 ) );
IADspMemoryTypeListPtr pMemoryTypeList = pProcessor->MemoryTypeList;

try
{
   IADspMemoryTypePtr pMemoryType = pMemoryTypeList->GetItem( "Data(DM) Memory" );
   IADspProgressPtr pProgress;
   pProgress.CreateInstance( "VisualDSP.ADspProgress" );
   try
   {
      pMemoryType->GetMemoryUnblocked( 0x30000, // начальный адрес
                                       10000,   // количество читаемых
                                       1,       // шаг
                                       pProgress, // объект прогресса
                                       1024 );  // размер блока
   }
   catch ( _com_error err )
   {
      pApp->PrintText( tabConsole, "GetMemoryUnblocked failed" );
   }
}

catch ( _com_error err )
{
   pApp->PrintText(tabConsole,"Processor doesn't have memory named \"Data(DM) Memory\"");
}

   Dim app As Application
   Dim session As ADspDebugSession
   Dim processor As ADspProcessor
   Dim memory_type_list As ADspMemoryTypeList
   Dim memory_type As ADspMemoryType
   Dim progress As ADspProgress

   Set app = CreateObject( "VisualDSP.ADspApplication" )
   Set session = app.ActiveSession
   Set processor = session.ProcessorList( 0 )
   Set memory_type_list = processor.MemoryTypeList

   On Error GoTo GetItemFailed
   Set memory_type = memory_type_list( "Data(DM) Memory" )

   On Error GoTo GetMemoryUnblockedFailed
   Set progress = new ADspProgress
   memory_type.GetMemoryUnblocked &h30000, 10000, 1, progress

   Exit Sub

GetItemFailed:
   app.PrintText tabConsole, "Processor doesn't have memory named ""Data(DM) Memory""

IADspApplicationPtr pApp;

pApp.CreateInstance( "VisualDSP.ADspApplication" );

// Не будет показываться ни один диалог:
pApp->Interactive = FALSE;

IADspProjectListPtr pProjectList = pApp->ProjectList;

try
{
   IADspProjectPtr pProject=pProjectList->CreateProject("My Project",
                                                        "c:\\examples\\test.dpj");
   // Установка опций проекта:
   pProject->PutProcessor( "ADSP-21065L" );
   pProject->PutTargetType( "Executable file" );

   // Добавление исходного файла в проект:
   pProject->AddFile( "c:\\examples\\test.c", "" );

   // Запуск сборки проекта:
   pProject->Build( TRUE );
}

catch ( _com_error err )
{
   pApp->PrintText( tabConsole, "Failed to create project" );
}

   Dim app As Application
   Dim project_list As ADspProjectList
   Dim project As ADspProject

   Set app = CreateObject( "VisualDSP.ADspApplication" )

   Rem Не показывать диалоги:
   app.Interactive = False

   Set project_list = app.ProjectList

   On Error GoTo CreateProjectFailed
   Set project = project_list.CreateProject( "My Project",
                                             "c:\examples\test.dpj" )
   Rem Установка опций проекта:
   project.Processor = "ADSP-21065L"
   project.TargetType = "Executable file"

   Rem Добавление исходного файла в проект:
   project.AddFile "c:\examples\test.c", ""

   Rem Запуск сборки проекта:
   project.Build True
   Exit Sub

CreateProjectFailed:
   app.PrintText tabConsole, "Failed to create project"

IADspApplicationPtr pApp;

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspProjectListPtr pProjectList = pApp->ProjectList;

for ( long i = 0; i < pProjectList->Count; i++ )
{
   IADspProjectPtr pProject = pProjectList->GetItem( i );
   pApp->PrintText( tabConsole, pProject->Name );
}

Dim app As Application

Dim project_list As ADspProjectList

Dim project As ADspProject

Set app = CreateObject( "VisualDSP.ADspApplication" )

Set project_list = app.ProjectList

For Each project In project_list
   app.PrintText tabConsole, project.Name

Next

IADspApplicationPtr pApp;
IADspProjectWindowPtr pProjectWindow;

pApp.CreateInstance( "VisualDSP.ADspApplication" );
pProjectWindow = pApp->ProjectWindow;
pProjectWindow->Visible = FALSE;

Dim app As Application

Dim projectWindow As ADspProjectWindow

Set app = CreateObject( "VisualDSP.ADspApplication" )

Set projectWindow = app.ProjectWindow
projectWindow.Visible = False

IADspApplicationPtr pApp;
TCHAR szBuffer[128];

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspDebugSessionPtr pSession = pApp->ActiveSession;
IADspProcessorPtr pProcessor = pSession->ProcessorList->GetItem( CComVariant( 0 ) );
IADspRegisterListPtr pRegisterList = pProcessor->RegisterList;

if ( NULL == pRegisterList )
{
   pApp->PrintText( tabConsole, "Target does not have any registers" );
}

else
{
   try
   {
      IADspRegisterPtr pRegister = pRegisterList->GetItem( "PC" );
      IADspValuePtr pValue = pRegister->GetValue();
      sprintf( szBuffer, "Value = %s  Width = %d",
               (char *) pValue->ToString( "Hexadecimal" ), pValue->Width );
      pApp->PrintText( tabConsole, szBuffer );
   }
   catch ( _com_error err )
   {
      pApp->PrintText( tabConsole, "Target does not have a PC register" );
   }
}

   Dim app As Application
   Dim session As ADspDebugSession
   Dim register_list As ADspRegisterList
   Dim register As ADspRegister
   Dim processor As ADspProcessor
   Dim value As ADspValue

   Set app = CreateObject( "VisualDSP.ADspApplication" )
   Set session = app.ActiveSession
   Set processor = session.ProcessorList( 0 )
   Set register_list = processor.RegisterList

   If (register_list Is Nothing) Then
       app.PrintText tabConsole, "Target does not have any registers"
   Else
      On Error GoTo GetItemFailed
      Set register = register_list( "PC" )
      Set value = register.Value
      app.PrintText tabConsole, "Value = " + value.ToString( "Hexadecimal" ) + _
                                "  Width = " + CStr( value.Width )
   End If

   Exit Sub

GetItemFailed:
   app.PrintText tabConsole, "Target does not have a PC register"

IADspApplicationPtr pApp;
TCHAR szBuffer[128];

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspDebugSessionPtr pSession = pApp->ActiveSession;
IADspProcessorPtr pProcessor = pSession->ProcessorList->GetItem( CComVariant( 0 ) );
IADspRegisterListPtr pRegisterList = pProcessor->RegisterList;

if ( NULL == pRegisterList )
{
    pApp->PrintText( tabConsole, "Target does not have any registers" );
}

else
{
   for ( long i = 0; i < pRegisterList->Count; i++ )
   {
      IADspRegisterPtr pRegister = pRegisterList->GetItem( i );
      sprintf( szBuffer, "Name = %s  Width = %ld",
               (char *) pRegister->Name,
               pRegister->Width );
      pApp->PrintText( tabConsole, szBuffer );
   }
}

Dim app As Application

Dim session As ADspDebugSession

Dim register_list As ADspRegisterList

Dim register As ADspRegister

Dim processor As ADspProcessor

Set app = CreateObject( "VisualDSP.ADspApplication" )

Set session = app.ActiveSession

Set processor = session.ProcessorList( 0 )

Set register_list = processor.RegisterList

If (register_list Is Nothing) Then
   app.PrintText tabConsole, "Target does not have any registers"

Else
   For Each register In register_list
      app.PrintText tabConsole, "Name = " + register.Name + _
                                "  Width = " + CStr( register.Width )
   Next

End If

IADspApplicationPtr pApp;

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspScriptEnginePtr pScriptEngine = pApp->ScriptEngine;
pScriptEngine->ScriptLanguage = "JScript";

try
{
   pScriptEngine->LoadScript( "c:\\examples\\test.js" );
}

catch ( _com_error err )
{
   pApp->PrintText( tabConsole, "Failed to load script" );
}

   Dim app As Application
   Set app = CreateObject( "VisualDSP.ADspApplication" )
   Set ScriptEngine = app.ScriptEngine
   ScriptEngine.ScriptLanguage = "JScript"

   On Error GoTo LoadFailed
   app.LoadScript "c:\examples\test.js"

   Exit Sub

LoadFailed:
   app.PrintText tabConsole, "Failed to load script"

IADspApplicationPtr pApp;

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspSessionListPtr pSessionList = pApp->SessionList;

for ( long i = 0; i < pSessionList->Count; i++ )
{
   IADspSessionPtr pSession = pSessionList->GetItem( i );
   pApp->PrintText( tabConsole, pSession->Name );
}

Dim app As Application

Dim session_list As ADspSessionList

Dim session As ADspSession

Set app = CreateObject( "VisualDSP.ADspApplication" )

Set session_list = app.SessionList

For Each session In session_list
   app.PrintText tabConsole, session.Name

Next

USES_CONVERSION;

TCHAR szText[1024];
IADspApplicationPtr pApp( "VisualDSP.ADspApplication" );
IADspSoftwareStackPtr pStack = pApp->ActiveSession->ActiveProcessor->SoftwareStack;

for( long i=0; i < pStack->Count; i++ )
{
   IADspSoftwareStackFramePtr pFrame = pStack->GetItem(i);
   sprintf( szText,
            "%s 0x%08x %s(%d)",
            OLE2A(pFrame->Function->Name),
            pFrame->Address,
            OLE2A(pFrame->FileName),
            pFrame->Line );
   pApp->PrintText( tabConsole, szText );
}

Dim app As Application

Dim stack As ADspSoftwareStack

Dim frame As ADspSoftwareStackFrame

Set app = CreateObject("VisualDSP.ADspApplication")

Set stack = app.ActiveSession.ActiveProcessor.SoftwareStack

For Each frame In stack
   app.PrintText tabConsole, _
        frame.Function.Name & " " _
        & Hex(frame.Address) _
        & " " & frame.FileName _
        & "(" & frame.Line & ")"

Next

IADspApplicationPtr pApp;

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspProjectListPtr pProjectList = pApp->ProjectList;
IADspProjectPtr pProject = pProjectList->ActiveProject;

if ( NULL == pProject )
{
   pApp->PrintText( tabConsole, "No project loaded" );
}

else
{
   for ( long i = 0; i < pProject->Count; i++ )
   {
      IADspSourceFilePtr pSourceFile = pProject->GetItem( i );
      pApp->PrintText( tabConsole, pSourceFile->FileName );
   }
}

Dim app As Application

Dim project_list As ADspProjectList

Dim project As ADspProject

Dim src_file As ADspSourceFile

Set app = CreateObject( "VisualDSP.ADspApplication" )

Set project_list = app.ProjectList

Set project = project_list.ActiveProject

If ( project Is Nothing ) Then
   app.PrintText tabConsole, "No project loaded"

Else
   For Each src_file In project
      app.PrintText tabConsole, src_file.FileName
   Next

End If

IADspApplicationPtr pApp;
TCHAR szBuffer1[512];
TCHAR szBuffer2[512];

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspDebugSessionPtr pSession = pApp->ActiveSession;
IADspStreamListPtr pStreamList = pSession->StreamList;

for ( long i = 0; i < pStreamList->Count; i++ )
{
   IADspStreamPtr pStream = pStreamList->GetItem( i );
   sprintf(szBuffer1,"Src: Type=%d Name=%s DevAdd=0x%lx FileFormat=%s IsCircular=%d Rewind=%d Processor=%s",
           pStream->SourceType, (char *) pStream->SourceName,  pStream->SourceDeviceAddress,
           (char *) pStream->SourceFileFormat, 
           pStream->SourceFileIsCircular, pStream->SourceFileRewind, (char *) pStream->SourceProcessor);
   sprintf(szBuffer2,"Dst: Type=%d Name=%s DevAdd=0x%lx FileFormat=%s Rewind=%d Processor=%s",
           pStream->DestinationType, (char *) pStream->DestinationName,
           pStream->DestinationDeviceAddress, (char *) pStream->DestinationFileFormat,
           pStream->DestinationFileRewind, (char *) pStream->DestinationProcessor);
   pApp->PrintText( tabConsole, szBuffer1 );
   pApp->PrintText( tabConsole, szBuffer2 );
}

Dim app As Application

Dim session As ADspDebugSession

Dim stream_list As ADspStreamList

Dim stream As ADspStream

Set app = CreateObject("VisualDSP.ADspApplication")

Set session = app.ActiveSession

Set stream_list = session.StreamList

For Each stream In stream_list
   app.PrintText tabConsole, "Source: Type = " + CStr(stream.SourceType) + _
                             "  Name = " + stream.SourceName + _
                             " DeviceAddress = " + CStr(stream.SourceDeviceAddress) + _
                             " FileFormat = " + stream.SourceFileFormat + _
                             " IsCircular = " + CStr(stream.SourceFileIsCircular) + _
                             " Rewind = " + CStr(stream.SourceFileRewind) + _
                             " Processor = " + stream.SourceProcessor
   app.PrintText tabConsole, "Destination: Type = " + CStr(stream.DestinationType) + _
                             "  Name = " + stream.DestinationName + _
                             " DeviceAddress = " + CStr(stream.DestinationDeviceAddress) + _
                             " FileFormat = " + CStr(stream.DestinationFileFormat) + _
                             " Rewind = " + CStr(stream.DestinationFileRewind) + _
                             " Processor = " + stream.DestinationProcessor

Next

IADspApplicationPtr pApp;
IADspStringListPtr pStringList;

pApp.CreateInstance( "VisualDSP.ADspApplication" );
pStringList.CreateInstance( "VisualDSP.ADspStringList" );

pStringList->Add( "String 1" );
pStringList->Add( "String 2" );
pStringList->Add( "String 3" );

for ( long i = 0; i < pStringList->Count; i++ )
{
   pApp->PrintText( tabConsole, pStringList->Item( i ) );
}

Dim app As Application

Dim string_list As ADspStringList

Dim str As Variant

Set app = CreateObject( "VisualDSP.ADspApplication" )

Set string_list = CreateObject( "VisualDSP.ADspStringList" )

string_list.Add( "String 1" )
string_list.Add( "String 2" )
string_list.Add( "String 3" )

For Each str In string_list
   app.PrintText tabConsole, str

Next 

IADspApplicationPtr pApp;
TCHAR szBuffer[128];

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspDebugSessionPtr pSession = pApp->ActiveSession;
IADspProcessorPtr pProcessor = pSession->ProcessorList->GetItem( CComVariant( 0 ) );
IADspMemoryTypeListPtr pMemoryTypeList = pProcessor->MemoryTypeList;

try
{
   IADspMemoryTypePtr pMemoryType = pMemoryTypeList->GetItem( "Program(PM) Memory" );
   IADspSymbolListPtr pSymbolList = pMemoryType->SymbolList;
   if ( NULL == pSymbolList )
   {
      pApp->PrintText( tabConsole, "No symbols in Program(PM) Memory" );
   }
   else
   {
      for ( long i = 0; i < pSymbolList->Count; i++ )
      {
         IADspSymbolPtr pSymbol = pSymbolList->GetItem(i);
         sprintf( szBuffer, "Symbol: %s  Address: 0x%lx",
                  (char *) pSymbol->Name,
                  pSymbol->Address );
         pApp->PrintText( tabConsole, szBuffer );
      }
   }
}

catch ( _com_error err )
{
   pApp->PrintText( tabConsole, "Processor doesn't have memory named \"Program(PM) Memory\"" );
}

   Dim app As Application
   Dim session As ADspDebugSession
   Dim processor As ADspProcessor
   Dim memory_type_list As ADspMemoryTypeList
   Dim memory_type As ADspMemoryType
   Dim symbol_list As ADspSymbolList
   Dim symbol As ADspSymbol

   Set app = CreateObject( "VisualDSP.ADspApplication" )
   Set session = app.ActiveSession
   Set processor = session.ProcessorList( 0 )
   Set memory_type_list = processor.MemoryTypeList

   On Error GoTo GetItemFailed
   Set memory_type = memory_type_list( "Program(PM) Memory" )
   Set symbol_list = memory_type.SymbolList

   If ( symbol_list Is Nothing ) Then
      app.PrintText tabConsole, "No symbols in Program(PM) Memory"
   Else
      For Each symbol In symbol_list
         app.PrintText tabConsole, "Symbol: " + symbol.Name + _
                                   "  Address: 0x" + Hex(symbol.Address)
      Next
   End If

   Exit Sub

GetItemFailed:
   app.PrintText tabConsole, "Processor doesn't have memory named ""Program(PM) Memory""

IADspApplicationPtr pApp;

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspProjectListPtr pProjectList = pApp->ProjectList;

if ( !pProjectList->Count )
{
   pApp->PrintText( tabConsole, "No project loaded" );
}

else
{
   // Получение объекта первого проекта:
   IADspProjectPtr pProject=pProjectList->GetItem(CComVariant(static_cast< long >(0)));
   // Просмотр списка инструментов и печать их свойств:
   IADspToolListPtr pToolList = pProject->ToolList;
   for ( long i = 0; i < pToolList->Count; i++ )
   {
      TCHAR szBuffer[1024];
      IADspToolPtr pTool = pToolList->GetItem( i );
      sprintf( szBuffer, "Tool Type = %s  Description = %s  Info = %s",
               (char *) pTool->Type, (char *) pTool->Description, (char *) pTool->Info );
      pApp->PrintText( tabConsole, szBuffer );
   }
}

Dim app As Application

Dim project_list As ADspProjectList

Dim project As ADspProject

Dim tool_list As ADspToolList

Dim tool As ADspTool

Set app = CreateObject( "VisualDSP.ADspApplication" )

Set project_list = app.ProjectList

If ( project_list.Count = 0 ) Then
   app.PrintText tabConsole, "No project loaded"

Else
   Rem Получение объекта первого проекта:
   Set project = project_list( 0 )

   Rem Просмотр списка инструментов и печать их свойств:
   Set tool_list = project.ToolList
   For Each tool In tool_list
      app.PrintText tabConsole, "Tool Type = " + tool.Type + _
                                "  Description = " + tool.Description + _
                                "  Info = " + tool.Info
   Next

End  If

IADspApplicationPtr pApp;

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspDebugSessionPtr pSession = pApp->ActiveSession;
IADspProcessorPtr pProcessor = pSession->ProcessorList->GetItem( CComVariant( 0 ) );
IADspMemoryTypeListPtr pMemoryTypeList = pProcessor->MemoryTypeList;

try
{
   IADspMemoryTypePtr pMemoryType = pMemoryTypeList->GetItem( "Data(DM) Memory" );
   try
   {
      IADspValueListPtr pValueList = pMemoryType->GetMemory( 0x30000, // начальный адрес
                                                             10,      // количество ячеек
                                                             1 );     // шаг
      for ( long i = 0; i < pValueList->Count; i++ )
      {
         IADspValuePtr pValue = pValueList->GetItem( i );
         pApp->PrintText( tabConsole, pValue->ToString( "Hexadecimal" ) );
      }
   }
   catch ( _com_error err )
   {
      pApp->PrintText( tabConsole, "GetMemory failed" );
   }
}

catch ( _com_error err )
{
   pApp->PrintText( tabConsole, "Processor doesn't have memory named \"Data(DM) Memory\"" );
}

   Dim app As Application
   Dim session As ADspDebugSession
   Dim processor As ADspProcessor
   Dim memory_type_list As ADspMemoryTypeList
   Dim memory_type As ADspMemoryType
   Dim value_list As ADspValueList
   Dim value As ADspValue

   Set app = CreateObject( "VisualDSP.ADspApplication" )
   Set session = app.ActiveSession
   Set processor = session.ProcessorList( 0 )
   Set memory_type_list = processor.MemoryTypeList

   On Error GoTo GetItemFailed
   Set memory_type = memory_type_list( "Data(DM) Memory" )

   On Error GoTo GetMemoryFailed
   Set value_list = memory_type.GetMemory( &h30000, 10, 1 )
   For Each value In value_list
      app.PrintText tabConsole, value.ToString( "Hexadecimal" )
   Next

   Exit Sub

GetItemFailed:
   app.PrintText tabConsole, "Processor doesn't have memory named ""Data(DM) Memory""

IADspApplicationPtr pApp;
TCHAR szBuffer[256];

pApp.CreateInstance( "VisualDSP.ADspApplication" );
IADspDebugSessionPtr pSession = pApp->ActiveSession;
IADspProcessorPtr pProcessor = pSession->ProcessorList->GetItem( CComVariant( 0 ) );
IADspWatchpointListPtr pWatchpointList = pProcessor->WatchpointList;

if ( NULL == pWatchpointList )
{
   pApp->PrintText( tabConsole, "Target does not support watchpoints" );
}

else
{
   for ( long i = 0; i < pWatchpointList->Count; i++ )
   {
      IADspWatchpointPtr pWatchpoint = pWatchpointList->GetItem( i );
      switch ( pWatchpoint->GetWatchpointType() )
      {
      case watchpointMemoryInclusive:
      case watchpointMemoryExclusive:
         sprintf( szBuffer, "Memory = %s 0x%lx-0x%lx",
                  (char *) pWatchpoint->MemoryType->Name,
                  pWatchpoint->StartAddress,
                  pWatchpoint->EndAddress );
         if ( watchpointMemoryInclusive == pWatchpoint->GetWatchpointType() )
         {
            strcat( szBuffer, ", Inclusive");
         }
         else
         {
            strcat( szBuffer, ", Exclusive");
         }
         break;
      case watchpointRegister:
         sprintf( szBuffer, "Register = %s",
                  (char *) pWatchpoint->Register->Name );
         break;
      case watchpointHardwareStack:
         sprintf( szBuffer, "Hardware Stack = %s",
                  (char *) pWatchpoint->HardwareStack->Name );
         break;
      default:
         strcpy( szBuffer, "Unknown" );
         break;
      }
      strcat( szBuffer, "   HaltCondition = " );
      if ( pWatchpoint->HaltCondition & watchpointHaltOnReadData )
      {
         strcat( szBuffer, "Read Data ");
         strcat( szBuffer, (char *) pWatchpoint->ReadValue->ToString( "Hexadecimal" ) );
         strcat( szBuffer, ", ");
      }
      if ( pWatchpoint->HaltCondition & watchpointHaltOnWriteData )
      {
         strcat( szBuffer, "Write Data ");
         strcat( szBuffer, (char *) pWatchpoint->WriteValue->ToString( "Hexadecimal" ) );
         strcat( szBuffer, ", ");
      }
      if ( pWatchpoint->HaltCondition & watchpointHaltOnReadUndefined )
      {
         strcat( szBuffer, "Read Uninitialized Data, ");
      }
      if ( pWatchpoint->HaltCondition & watchpointHaltOnWriteUndefined )
      {
         strcat( szBuffer, "Write Uninitialized Data, ");
      }
      if ( pWatchpoint->HaltCondition & watchpointHaltOnReadAnyValue )
      {
         strcat( szBuffer, "Read Any Data, ");
      }
      if ( pWatchpoint->HaltCondition & watchpointHaltOnWriteAnyValue )
      {
         strcat( szBuffer, "Write Any Data, ");
      }
      if ( pWatchpoint->HaltCondition & watchpointHaltOnRegisterReadInComputation )
      {
         strcat( szBuffer, "Register Read In Computation, ");
      }
      if ( pWatchpoint->HaltCondition & watchpointHaltOnRegisterWriteInComputation )
      {
         strcat( szBuffer, "Register Write In Computation, ");
      }
      if ( pWatchpoint->HaltCondition & watchpointHaltOnUnderflow )
      {
         strcat( szBuffer, "Underflow, ");
      }
      if ( pWatchpoint->HaltCondition & watchpointHaltOnOverflow )
      {
         strcat( szBuffer, "Overflow, ");
      }
      // Избавление от последней запятой в конце строки:
      if ( szBuffer[ strlen( szBuffer ) - 2 ] == ',' )
         szBuffer[ strlen( szBuffer ) - 2 ] = 0;
      pApp->PrintText( tabConsole, szBuffer );
   }
}

Dim app As Application

Dim session As ADspDebugSession

Dim watchpoint_list As ADspWatchpointList

Dim watchpoint As ADspWatchpoint

Dim processor As ADspProcessor

Dim buffer As String

Set app = CreateObject( "VisualDSP.ADspApplication" )

Set session = app.ActiveSession

Set processor = session.ProcessorList( 0 )

Set watchpoint_list = processor.WatchpointList

If (watchpoint_list Is Nothing) Then
   app.PrintText tabConsole, "Target does not support watchpoints"

Else
   For Each watchpoint In watchpoint_list
      Select Case watchpoint.WatchpointType
      Case watchpointMemoryInclusive
         buffer = "Memory = " + watchpoint.MemoryType.Name + _
                  " 0x" + Hex(watchpoint.StartAddress) + _
                  "-0x" + Hex(watchpoint.EndAddress) + ", Inclusive"
      Case watchpointMemoryExclusive
         buffer = "Memory = " + watchpoint.MemoryType.Name + _
                  " 0x" + Hex(watchpoint.StartAddress) + _
                  "-0x" + Hex(watchpoint.EndAddress) + ", Exclusive"
      Case watchpointRegister
         buffer = "Register = " + watchpoint.Register.Name
      Case watchpointHardwareStack
         buffer = "Hardware Stack = " + watchpoint.HardwareStack.Name
      Case Else
         buffer = "Unknown"
      End Select
      buffer = buffer + "   HaltCondition = "
      If ( watchpoint.HaltCondition And watchpointHaltOnReadData ) Then
         buffer = buffer + "Read Data " + _
                  watchpoint.ReadValue.ToString( "Hexadecimal" ) + ", "
      End If
      If ( watchpoint.HaltCondition And watchpointHaltOnWriteData ) Then
         buffer = buffer + "Write Data " + _
                  watchpoint.WriteValue.ToString( "Hexadecimal" ) + ", "
      End If
      If ( watchpoint.HaltCondition And watchpointHaltOnReadUndefined ) Then
         buffer = buffer + "Read Uninitialized Data, "
      End If
      If ( watchpoint.HaltCondition And watchpointHaltOnWriteUndefined ) Then
         buffer = buffer + "Write Uninitialized Data, "
      End If
      If ( watchpoint.HaltCondition And watchpointHaltOnReadAnyValue ) Then
         buffer = buffer + "Read Any Data, "
      End If
      If ( watchpoint.HaltCondition And watchpointHaltOnWriteAnyValue ) Then
         buffer = buffer + "Write Any Data, "
      End If
      If ( watchpoint.HaltCondition And watchpointHaltOnRegisterReadInComputation ) Then
         buffer = buffer + "Register Read In Computation, "
      End If
      If ( watchpoint.HaltCondition And watchpointHaltOnRegisterWriteInComputation ) Then
         buffer = buffer + "Register Write In Computation, "
      End If
      If ( watchpoint.HaltCondition And watchpointHaltOnUnderflow ) Then
         buffer = buffer + "Underflow, "
      End If
      If ( watchpoint.HaltCondition And watchpointHaltOnOverflow ) Then
         buffer = buffer + "Overflow, "
      End If
      Rem Избавление от последней запятой в конце строки:
      buffer = Left(buffer, Len(buffer) - 2)
      app.PrintText tabConsole, buffer
   Next

End If