1. Vinculum II Software Development Toolchain

2. Introduction
VNC2, introduces new firmware development model, supporting user developed firmware.
Opens up many more potential applications for VNC2.
Firmware model
VNC2 real-time operating system (RTOS).
VNC2 device drivers.
User applications development – Tool Chain.
Precompiled Firmware (same as VNC1).
Based on a modular, layered architecture for maintainability and ease of use.
Firmware model is consistent with traditional embedded systems design approach.
Introduction on VNC2 firmware. Main point is that VNC2 supports user developed firmware. In order to support this FTDI have developed a new firmware support model which is based around an RTOS, device drivers, tool chain for user application development and pre-compiled firmware as in VNC1L.
With the exception of the pre-compiled firmware the FTDI approach is consistent with the approach used when designing with traditional embedded processor systems. Developers of the VNC2 will be comfortable with the concept of an RTOS and device drivers.

3. VNC2:Software Architecture
Stdlib
Libraries
Stdio
User Application
Math
Device Manager
File System
Upper Level Drivers
Vinculum II Tool Suite
Kernel Services
SD Card
BOMS
HID
HUB
CDC
FT232
Hardware Interface Drivers
UART
FIFO
SPI Slave
SPI Master
USB Host
USB Slave
Vinculum II Hardware
FTDI Supplied Content

4. Development Tool Chain Suite
VinL
VinC
Firmware
&
Libraries
Tool chain
VinAsm
VinDbg
Source Files
Vinculum II Chip
Here is the block diagram for the IDE. As you can see in the diagram it acts as the mediator between the different components of software development. It gets the source files of the user and using the tools compile, assemble and link it together with the firmware and libraries (if necessary) to create the final executable ROM file and by using the debugger, programs and debugs the Vinculum II hardware. This is done with the least amount of user intervention as possible thus expediting the software development process
VinIDE

5. Integrated Development Environment
Provides the environment to develop Vinculum II-based applications
Easy-to-use GUI based environment, incorporates ability to edit, build and debug projects.
Command line tools available.
Integrates RTOS and drivers.
Has many of the features of commercial IDEs used in the industry today
The IDE is developed specifically for the Vinculum II chip to make it easier for those who want to develop software for the chip.
It provides a handy user interface for faster and easier development rather than to write lengthy and sometimes difficult scripts to build your projects. The IDE allows you to do all that with just a click of your mouse.
It takes from the developer the burden of having to configure the tools as well as the firmware thus making it easier to focus more on their applications
The IDE provides most of the functionalities that are available with the other IDEs for the customer to use

6. VinIDE Key Features Built-in multi-file source editor
Windows® Vista-style user interface
Dockable panel windows
Windows® XP/Vista/7 compatible
Project management capability
Highly customizable
Syntax styler for C code
Code auto-completion functionality
Grep(search) functionality
Key Features
The user can open multiple files with each file shown on a different tab so the user can navigate freely between files
The IDE incorporates the Ribbon toolbar interface as well as Vista-style dialog boxes for a better–look user interface
All the panel windows are dockable using the Microsoft visual studio-like docking mechanism to allow for visual customizations depending on the user’s preferences
The IDE can be used on XP as well as with newer Windows 7 machines to enable its use without having to worry about compatibility
It allows the user full control of the project like adding/removing of files and the order the files are going to be build and the different settings for a given project
It also allows the user the means to configure the IDE behavior and look according to the user’s personal preferences like changing the colors and fonts of the editor and all those things
The source editor has a built-in syntax styler that automatically recognizes the different parts of a C or assembly file like comments, reserved words and highlights them to the programmer making the source files easier to read
Aside from the syntax styler, the source editor also has the auto-completion functionality where the IDE can automatically display needed information like function parameters, variable recognition, etc..
The Grep functionality allows the user to search from all the files included in the project. This feature is very useful especially when navigating through the code.

7. VinIDE Major Components Ribbon Toolbar Watch Window Project Manager
Source Editor
Memory Window
Here is a screenshot of the main window of the IDE with the major components. The following slide will discuss these components and what they do
Breakpoint Window
Messages Window

8. VinIDE Major Components Ribbon ® Toolbar Source Editor
- A tabbed toolbar organizing relevant commands into groups for easier access
Source Editor
- Multi-file, tabbed source editor with syntax highlighting for easier code development
Project Manager
- Displays and organizes the files included in the project
Watch Window
- Used to evaluate values of variables and expressions.
Memory Window
- Used to view the current memory data
The ribbon toolbar groups the commands into logical groups making it easier for the user to know where to look for a specific command
The source editor is where the source files are displayed and can be edited. Multiple files can be opened and edited at the same time. Each open file has its own gutter display that shows information like the line numbers and the modified lines. It is also used to set a breakpoint on that particular line during debugging.
The project manager window lists down the files that make up the project in a tree view form. The commands in the toolbar relating to the project files can also be accessed here by using the mouse right click.
The watch window list down the variables that are being evaluated or watched. This is used during debugging.
The memory window displays the contents of the chips memory. Also used during debugging.

9. VinIDE Major Components Messages Window Breakpoint Window
- Used to display information from the other tools as well as the Grep results
Breakpoint Window
- Used to manage the breakpoints for debugging the project application
The messages window displays the information that are received by the IDE from the tools that it invokes like the compiler for the user to see. It also displays the results of the grep search.
This is the same as with the watch window only for breakpoints. Also used when debugging.

10. Software Development Flow
Typical development flow:
*.bin/*.rom file
IDE
*.obj file
*.asm file
VNC2
Linker
Assembler
COMPILER
Takes output from previous and generates file to be loaded into device.
VinL
Code is translated into low-level device commands.
VinASM
User writes code in ‘C’ language.
VinC
Debugger
Code running in device. Verify code operation on device.
VinDbg

11. VinC Compiler: Key Features
ANSI C Compatible Compiler
With some customizations to optimize memory usage.
Extended C Language Features
To support Harvard memory architecture
To access and modify hardware I/O Ports
Support for Bit-Operations with ports and variables
Validation of C programs
Validates input C files for syntax, semantics and type errors
Language restrictions
No floating point support.
Passing of structures or unions as parameters not supported. Use pointers instead.
Variable length arrays not supported.
Vinculum II comes with a C language compiler known as VinC. VinC is an ANSI C compatible compiler with few customizations to provide better memory utilization.
In addition, VinC also support some language level enhancement of ANSI C: to support Harvard memory architecture, to access and modify hardware I/O Ports, to support for Bit-Operations with ports and variables, to support for Inline Assembly.
VinC implements validation of input c programs for syntax, semantics and type errors and reports them to the user. It proceeds with the compilation only when the validation is successful.
VinC defines a formal calling convention; this allows creating projects with C, ASM programs and call them from one another

12. VinC: Supported Data Types
Size
Range
unsigned char
1 Byte
char
unsigned short
2 Byte
short
unsigned int
4 Byte
int
unsigned long
long

13. Supported ANSI C Features (Summary)
Data types and related
Primitive data Types
Structures and Unions
Enumerations
Pointers, including function pointers
Arrays
Bit-fields
Casting
Scopes
typedefs
Primitive data types means int, char and float. But as mentioned float data type is not supported.
Secondary data types are structures, unions, arrays, bit fields and pointers

14. Supported ANSI C Features (Summary)
Function
Function Definitions
Function Declarations and Prototypes
Variable Parameter Lists

15. Supported ANSI C Features (Summary)
Operators
Precedence and Order of Evaluation
Arithmetic Conversions
Postfix Operators
C Unary Operators
Cast Operators
Multiplicative Operators
C Additive Operators
Bitwise Shift Operators
Relational and Equality Operators
C Bitwise Operators
Logical Operators
Conditional-Expression Operator
Assignment Operators
Sequential-Evaluation Operator
Operator precedence table as supported in ANSI-C

16. Supported ANSI C Features (Summary)
Statements
Label and Jump statements
Compound statements
Expression and null statements
Selection statements (if-then-else, switch-case)
Iteration statements (for, while, do-while)

17. C Language Extensions
ROM Storage Qualifiers specifies that data needs to be placed in Flash
Example:
Port data types are special types to allow direct access to I/O ports.
Bit Operations adds special syntax to allow setting and clearing specific bits in ports and variables.
rom char x[5] = { 1,2,3,4,5};
rom char *str = "Hello";
port /* define interrupt register at I/O address 200 */
interrupt_reg = 4; /* clear interrupt register bit */
port 0x100
/* Setting Bit 0 of the DMA CTL register */
CPU_DMA1_CTL . 1 = 1;

18. VinC Compiler Optimizations
Copy Propagation.
Common Sub Expression Elimination.
Dead Code Elimination.
Constant Propagation and Folding.
Loop Invariant Code Motion.
Jump Optimization.
Register Emulation.
Peephole Optimization.
Supports optimisation levels.
Level 1-4 (highest optimisation).
Default optimization level 3.
VinC implements intermediate level and core specific optimizations while generating V2 code from C files
VinC supports user configuration options to manage the compile process, including optimizations.

19. C Library Compiler supplied with pre-implemented ANSI C library subset
Library provides common functionality as defined in ANSI C Library specification
Current C library functions provide
String manipulation/handling
Dynamic memory management
Character classification functions
File IO over USB
String.h
(String related)
Stdio.h
(File Input/
Output)
Ctype.h (character classificatio n functions)
Stdlib.h (Dynamic memory allocation and others)
More will be added in later releases
Vinculum 2 comes with C library subset. This C library subset is based on ANSI C specification and it is written combination of C and ASM for optimization.
Current version of C library supports String manipulation/handling, Dynamic memory management, Character classification functions and File IO over USB
More will be added in the future releases.

20. Assembler (VinAsm)
VinAsm assembler tool used by the toolchain to convert object code to assembly instructions.
Disassembly code can be viewed via debugger output.
Assembly programming currently not supported within tools.

21. VinL: Linker Carries out standard software toolchain linker functions.
Takes output from compiler/assembler.
Links code from referenced libraries.
Code optimisation. Adds debug info.
Program loading.
Supports user configuration options.
Standardised file support.
DWARF2 and ELF compatible object and archive file support.
VinL provides options to configure linker for ease of access. Also, linker supports other standard options like map file generation, binary CRC checksum and binary protection.
VinL supports dynamic segment definition this means user can define own memory segment considering memory architecture, other wise linker will use default memory segment architecture.
VinL also supports absolute address for specific symbol, this means in assembly file or C file user can define if specific function should go to specific address.
Unused code in program will be removed if optimization is enabled in linker this method is known as dead code elimination.
VinL linking process is static linking so it doesn’t support relocatable executable generation and dynamic loadable module executable support.
VinL also supports debug information processing as per DWARF2 standard. VinL only supports standard ELF compliant object and archive file processing.

22. Debugger (VinDbg) Supports debugging of software code on VNC2 device.
Supports standard features expected from debugger.
Features
- Set and clear breakpoints.
Walk-through code: Step-in, step-out, step-over and single step through code.
Halt the program from executing.
On screen editing of data value.
Debug interface required on VNC2 hardware.
Use VNC2 Debug Module.
User implements circuitry on their board.
Breakpoints:
One of the many basic feature of a debugger are Setting and Clearing a breakpoint.
Breakpoints are intentional stopping or pausing place in a program where the user can inspect the program to find out whether the it functions as expected.
Program Flow Control:
Next are the Program flow controls.
Program flow controls are controls where the user can go thru the source codes line-by-line and can inspect the values of the variables as the user steps thru the codes. It can also inform the user if the program executes or goes thru the expected lines of code.
Step-in into a function will single-steps through instructions in the program, and enters each function call that is encountered.
Step-out a function will execute the program out of a function call, and stops on the instruction immediately following the call to the function. Using this command, you can quickly finish executing the current function after determining that a bug is not present in the function.
Step-over a function. If this command is used when you reach a function call, the function is executed without stepping through the function instructions.
Single Stepping of code will single-steps through instructions in the program
Halt the program from executing:
At any desired point, the user can halt the program execution and inspect the program whether it functions as expected by examining the values of the variable and checking if it steps-thru the expected line of code.
Support for On-Screen Editing of data-value:
While on debugging mode or at halt, the user can manually change the value of the variables. It will give the developer an opportunity to observe an alternate program outcome by changing the value of the variables.
Support for Multi-Level Debugging:
Vinculum II Debugger support multi-level debugging. It will allow the user to debug both in C and assembly language code.

23. Demonstration Software Installation

24. Plugins – IOMux Utility
Software utility for setting device IOMux configuration.
Graphical interface provides easy configuration.
Utility generates IOMux code for user software program.

25. Vinculum II IDE (1.04)
Current release v1.04 available from FTDI website.
Users need to fill out short registration questionnaire to gain access to the download page.
Tools available free of charge. FTDI standard warranty and licence statement:
Examples:
GPIOKitt
HelloWorld
Philosophers
Getting started guide and cheat sheet available.
PWM Breathe
Runtime
Template
USB Host examples