<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'

	#*****************************************************************************
	#
	# index.php
	#
	# Author: 		Dave Russo
	# Date:			2008-July-8
	#
	# Description: RTSC main page (cloned from TM)
	#
	#
	#****************************************************************************
	
	#
	# Begin: page-specific settings.  Change these. 
	$pageTitle	= "RTSC Home page";
	$pageKeywords	= "device, target, component";
	$pageAuthor	= "Dave Russo";
	
 	# Add page-specific Nav bars here
	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
	# $Nav->addNavSeparator("My Page Links", 	"downloads.php");
	# $Nav->addCustomNav("My Link", "mypage.php", "_self", 3);
	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 3);

	# End: page-specific settings
	#
		
	# Paste your HTML content between the EOHTML markers!	
	$html = <<<EOHTML

<div id="rightcolumn">
    <div class="sideitem">
        <h6>Incubation</h6>
        <div align="center"><a href="/projects/what-is-incubation.php"><img 
            align="center" src="/images/egg-incubation.png" 
            border="0" alt="Incubation" /></a></div>
    </div>

    <div class="sideitem">
        <h6>Getting started</h6>
	<ul>				
          <li><a href="http://rtsc.eclipse.org/docs-tip/XDCtools_User%27s_Guide">User's Guide</a></li>
	</ul>
	<ul>				
          <li><a href="http://rtsc.eclipse.org/docs-tip/FAQ-080713-9">What's RTSC-Pedia?</a></li>
	</ul>
	<ul>				
          <li><a href="http://rtsc.eclipse.org/docs-tip/High-Level_FAQs">High-Level FAQs</a></li>
	</ul>
	<ul>				
          <li><a href="http://www.eclipse.org/proposals/rtsc">Project Proposal (archived)</a></li>
	</ul>
     </div>
</div>

<div id="maincontent">
	<div id="midcolumn">
		<h1>$pageTitle</h1>
		The <b><a href="http://www.eclipse.org/dsdp/rtsc/">Real-Time Software Components (RTSC)</a></b> 
		project provides foundational tools and low-level runtime content to enable
		component-based development using the C language targeting <I>all</I> embedded platforms.
		<p>
		While other component technologies exist for embedded systems, RTSC
		is unique in that it scales down to highly resource constrained embedded
		systems including DSPs and 16-bit micro-controllers. In addition, RTSC
		components have a "dual existance": in addition to embedded
		target code, they include code that executes on a rich client platform
		to help manage the component's <I>entire</I> lifecycle - from building the
		component to monitoring the real-time operation of the component within
		a deployed application.  This dual existance enables RTSC components to
		fully leverage Eclipse infrastructure without incurring overhead on the
		embedded platform.
		<p>
		The starting point for the RTSC project will include the XDCtools currently available from Texas
		Instruments as a free <a href="http://software-dl.ti.com/dsps/dsps_public_sw/sdo_sb/targetcontent/rtsc">download</a>.
		By making these tools freely and openly available, we hope to foster
		deeper levels of integration with the Eclipse platform, encourage adoption of RTSC by eliminating the
		understandable fears of proprietary ties to Texas Instruments, and bring modern component-based development
		tools to the embedded C programmer.
	</div>
</div>

EOHTML;

	# Generate the web page
	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
?>
