- 1 What is the Target Communication Framework (TCF)?
- 2 What is the current status of TCF?
- 3 The TCF Protocol
- 4 The TCF Contribution
- 5 How does TCF compare to ECF?
- 6 How can I contribute to this FAQ?
What is the Target Communication Framework (TCF)?
TCF is a vendor-neutral, lightweight, extensible network protocol mainly for communicating with embedded systems (targets). Its most distinguishing feature is that TCF is designed to transparently plug in value-adding servers between the tool and the target. But even without value-add, the protocol has the potential to unify lots of currently independent communication links, thus saving resources and making setup and configuration much easier than in current embedded development scenarios.
The protocol has a transport-agnostic channel abstraction, so it does not depend on any specific transport such as TCP/IP, Serial Line, SSH tunnel, etc. In fact, any third-party vendor can contribute a value-add server to do transport conversion from a standard TCP/IP channel into custom channels such as JTAG (Joint Test Action Group) or even proprietary hardware connections: all services can immediately route through the new transport and take immediate advantage of the value-add.
On top of the protocol specification, which is the core of TCF, the project includes a plain-C implementation of a lightweight extendable target agent, Java client API (usable stand-alone or on top of Eclipse), Python and Lua client APIs, complete debugger UI implementation in Eclipse, integration with CDT, Target Explorer, documentation and usage examples.
Where can I Read Documentation?
- TCF Getting Started - Hands-on: Getting the code, Building an agent, Making a first connection
- EclipseCon 2010 - TCF Helios Update - The Elevator Pitch (13 slides .odp | .ppt | Slideshare)
- EclipseCon 2009 TCF Tutorial - The most complete presentation including concepts, architecture and implementation (70 slides, 730KB)
- TCF Project Summary Page - Committer activity, involved parties, IP Log etc
- TCF 1.0 Release Review Material - Current State of the Project
TCF Architecture and Design Documents:
- Document Index
- TCF Project Overview - Project goals and results
- TCF Specifications - software design considerations, design goals, requirements and format of the TCF communication protocol and framework API
- TCF Service Definitions - The TCF communication model is based on the idea of services. A service is a group of related commands, events and semantics. New services are expected to be defined by developers of tools and target agents. To achieve a certain level of compatibility of tools/targets, TCF includes definitions of common services
- TCF Context Identifier Explanation - Most if not all TCF service functions need some way to identify what entity (e.g. process, thread, task, device on JTAG scan chain, etc.) they should operate on. To do this TCF uses a context identifier (aka ContextId). This document attempts to explain how ContextIds are intended to be used.
- TCF Agent Prototype - A brief description of the TCF target agent prototype C implementation
- TCF Agent Porting Guide - A guide for porting and customizing TCF agent code
- TCF UDP Discovery - TCF UDP Discovery protocol specifications
Notes of some previous TCF/Meetings
What is the current status of TCF?
- TCF is actively being developed on its Eclipse TCF Git Repository
- Use the TCF: Open Bugs query to see what bugs and enhancement requests are currently worked on
- Join the firstname.lastname@example.org mailing list for discussions and news about TCF
- The tcf-dev mailing list also gets notified whenever a new bug or enhancement request is filed against TCF
- Join the email@example.com mailing list for general discussions about the Target Management project
- The EclipseCon 2008 TM Tutorial includes in-depth material about TCF, including sample code (available from the download site); be sure to also read the EclipseCon 2010 TCF Update for Helios
- TCF is ready to jump on - it graduated to a mature 1.0 project with Eclipse Juno (2012)
New & Noteworthy, and Plans
- TCF 1.1 New & Noteworthy (Eclipse 4.3 Kepler, Jun 2013)
- TCF 1.2 New & Noteworthy (Eclipse 4.4 Luna, Jun 2014)
- TCF 1.3 New & Noteworthy (Eclipse 4.5 Mars, Jun 2015)
- TCF 1.4 New & Noteworthy (Eclipse 4.6 Neon, Jun 2016)
- TCF 1.5 New & Noteworthy (Eclipse 4.7 Oxygen, Jun 2017)
How can I get more involved?
- Ask questions on the firstname.lastname@example.org mailing list
- File a bug against TCF. This will automatically notify the tcf-dev mailing list as well!
The TCF Protocol
What is so special about the TCF protocol?
- TCF makes it simple to add value-adding servers into the host-target communication link: Instead of wrapping higher-level services like piggypack on top of lower ones, all services are on the same protocol layer. Therefore, servers can be plugged into the communication link transparently - no matter whether they're hardware or software components. An example of a value-adding server would be a debug engine providing translation between high-level language and assembly language debugging, or operating system awareness adding information like which process or thread is currently executing when the target does not explicitly provide such information.
- TCF provides for tunneling, addressing and auto-discovery all through one single, simple protocol such that the target agent can be small and lightweight. A reference implementation of such a lightweight agent is included for Linux, Windows and VxWorks.
- There is a single abstraction for a "Channel" to support message-based host/target communication. Currently, channels are supported on TCP/IP only, but other communication and addressing schemes can be added easily. All higher-level services operate on the Channel abstraction.
- The Tool_Target_Communication_Vision_v5.ppt (437 KiB) presentation shows this idea quite nicely: all tools and value-added components just talk using a single protocol with a single configuration over a single link (on slides 4..7).
What Layers of the OSI Model does TCF address?
In terms of the OSI (Open Systems Interconnection) Model, TCF addresses layers 5 through 7: reliable end-to-end transport is currently assumed to be available from underlying carriers. TCF cares for (5) Session Layer - Interhost communication; (6) Presentation Layer - Data representation and encryption through JSON; (7) Application Layer - TCF Services can be seen as Applications.
Depending on where TCF will be applied, it could also provide services for the (3) Network Layer - Path determination and logical addressing (IP) as well as the (4) Transport Layer - End-to-end connections and reliability (TCP) in the future, simply by implementing the TCF "Channel" abstraction with such lower-level transport services as well.
The TCF Contribution
What is included in the TCF project?
In addition to the core Protocol and associated documentation, the project also consists of:
- Definition and implementation of core services:
- Locator (for addressing)
- Remote File Access (File System Service)
- Remote Processes Access (Processes Service)
- Remote system status (System Monitor Service)
- Debug Services (Memory, Run Control, Registers, Stacktrace, Breakpoints, Symbols, Line Numbers, Expressions)
- A reference agent implementation in plain C, tested on Linux, Windows and VxWorks
- Reference client implementations in Java and plain C (commandline testing client)
- Tools using the services:
- Target Explorer - an extensible toolkit for managing, exploring and configuring remote targets
- Eclipse Debug Platform integration - a full featured debugger for C/C++ applications
- Example implementation of a value-add server (plain C)
- Example custom service add-on (plain C agent and Java client)
Where can I get TCF, and how do I get started?
Clone TCF Java source code from Eclipse GIT repository, using one of the following commands (note: ssh access into Gerrit is preferred for contributions):
git clone git://git.eclipse.org/gitroot/tcf/org.eclipse.tcf.git
git clone ssh://<user>@git.eclipse.org:29418/tcf/org.eclipse.tcf.git
git clone http://git.eclipse.org/gitroot/tcf/org.eclipse.tcf.git
Look at the documentation rooted at docs/index.html. The TCF Getting Started document, which is also part of the documentation, shows how to build and set up a Workspace with TCF.
We also have step-by-step instructions for some popular targets:
How is TCF licensed?
All TCF code is licensed under the Eclipse Public License (EPL) v1.0.
In addition to that, the plain C agent code is also licensed under the Eclipse Distribution License (EDL) v1.0, which is basically a very permissive BSD License in order to make it easier to redistribute the agent binaries linked into embedded devices such as mobile phones and the like with even less obligations than the EPL. To be clear, the agent is dual-licensed under both EPL and EDL which means that adopters can choose under which license they want to use it.
What other components does TCF depend on?
The core TCF protocol is just a specification, so it does not depend on anything -- the protocol can be implemented in any language within any environment.
The reference agent can currently be built on Linux, Windows and VxWorks, and uses POSIX services only.
The Java core protocol client is pure Java and does not have any particular dependencies.
The Target Explorer and Platform Debug tools are tightly integrated into Eclipse and cannot be used outside Eclipse.
Where can I ask questions about TCF?
Write an E-Mail to the email@example.com mailing list.
How does TCF compare to ECF?
TCF defines the protocol, independent of application programming interfaces (APIs). ECF defines the APIs, independent of protocol. It's as simple as that. Or, to be more elaborate:
TCF is a "vertical" technology stack: it includes all components needed to communicate with embedded remote systems end-to-end. This includes the plain C lightweight target agent, the TCF protocol specification at its core, the Java protocol API as well as 3 example clients.
ECF, on the other hand, is a "horizontal" technology: it deals with Eclipse Java APIs for a host of different protocols for any kind of communication needs. ECF wants to unify the usage patterns on the client side, such that protocols are exchangeable.
Therefore, the intersection (overlap) of TCF and ECF is on the Java client API, which makes up about 20% of the TCF contribution. Here are some thoughts on that overlap:
- Both TCF and ECF have asynchronous APIs (request/callback and publish/subscribe, respectively).
- ECF allows clients to call into the APIs from any thread, and responds with callbacks on any thread.
- TCF translates all incoming calls to one well-defined thread and responds with callbacks on one well-defined thread. This may sometimes make it easier for clients and service providers to ensure data integrity.
- Both TCF and ECF have APIs for remote file transfer and discovery. The means for addressing are different, though: ECF Namespaces/IDs vs. simple IP address with implicit TCF protocol in TCF. Only TCF currently supports remote browsing (directory retrieval).
- TCF currently supports point-to-point communications only, whereas ECF supports one-to-many and many-to-many communications (The underlying metaphor is "Joining a communications container").
- ECF's charter to strive for generic interfaces makes it hard to prototype new communication protocols, or to drive features that one protocol has but another has not. The API is either the least common denominator of all protocols to be supported, or it has to provide mechanisms for querying remote capabilities such that features can be enabled/disabled - which makes using such interfaces harder for the client.
Summing up, it seems that while TCF is still incubating, it will be easier to stick with a Java API that's defined in TCF alone and develop the contribution under the TM project; issues with dependencies and release cycles would otherwise make it unnecessarily complex to evolve the TCF protocol that is at the core of the contribution. At the same time, however, technology should be transferred between TCF and ECF as follows:
- TCF means for general API access, addressing and discovery should be reviewed and potentially aligned with the corresponding ECF mechanisms, to ensure that clients don't need to learn multiple programming paradigms for communications, and to ensure that TCF and ECF can eventually be combined into a single API.
- ECF APIs should be reviewed and/or extended to provide the features required by TCF, such that TCF fileshare and discovery implementations can eventually be implemented on top of ECF interfaces (thus TCF being just another ECF provider).
For more details, see also TCF/Meetings/Dec 4 2007 TCF-ECF Sync-up and Integration
How can I contribute to this FAQ?
This is a collaborative FAQ. Feel free to correct anything you think may be wrong, not clearly answered, or has a typo. Also feel free to add more questions and answers to this document.
The idea is that through collaborative editing, the document will eventually evolve. We welcome all contributions, anybody is invited to edit this Wiki page. Don't be shy about breaking anything - the page is being monitored and obvious mis-edits will be cleared by all the knowledgeable people monitoring the page.
How can I get notified of additions to this FAQ?
Log in to the Wiki. On your personal Preferences page, enable E-Mail notification. Then, click the watch tab of this page.