AFL Library

This is read-only version of AFL library entry. Ability to add user formulas and comment is only available from members-only area.

Details:

DISCLAIMER: Most formulas present in AFL on-line library are submitted by the users and are provided here on an "as is" and "as available" basis. AmiBroker.com makes no representations or warranties of any kind to the contents or the operation of material presented here. We do not maintain nor provide technical support for 3rd party formulas.
Description:

Updated version

This is a fully functional auto trading program for use with Interactive Brokers TWS. It is designed to trade futures contracts but can be modified, by you, for any ticker. It is provided as is and without support. Expect bugs! See the setup instructions at the bottom of the program. The system is a simple MA crossing that is provided for testing but is not profitable. Don\\\'t use it for trading and don\\\'t use this program unattended. Test your system with this program thoroughly before using it with real money to make sure it works to your satisfaction. You must agree not to hold me responsible for any losses when using this program. There are too many variables out of my control, including your system design, the internet, the AutoTrading interface, TWS errors or changes and their data quality and availability. Unless you agree DO NOT use this program.

Formula:

_N(SectionName = "AutoTrader Basic Flow");
_N(Ver = "Ver1_0"); 

_SECTION_BEGIN(SectionName);  
EnableTextOutput(False); // prevents incidental text from being displayed in
the interpretation
Filename = StrLeft(_DEFAULT_NAME(),StrLen(_DEFAULT_NAME())-2) + " " + Ver; //
the name of the program and is displayed on the title line
// CAUTION: VarPfx is used to make the static variables unique tp prevent
bizarre results if you use multiple versions of the trading program
simultaneously. 
VarPfx = Filename + Ver + Name();  

_N(Title = Filename + StrFormat(" - {{DATE}} \nOpen %g, Hi %g, Lo %g, Close %g
Vol %g " + " {{VALUES}}", O, H, L, C, V ));
RequestTimedRefresh(1);
SetChartOptions(0, chartShowDates); 

pAutoTrading 		= ParamToggle("AutoTrade", "Off|Running");					// turns auto
trading on and off
DebugOn 			= ParamToggle("DebugView","Off|Running",0); 		// Dumps trade data to
an output window
closetime			= Param("Close time (hhmmss)", 160000, 0, 245959, 1500);  	// end
trading at the time specified

// The chart period below must agree with the chart before AutoTrading wii
connect to TWS.
// The chart period below must agree with the chart before AutoTrading wii
connect to TWS.
// the following lines define the acceptable periods that auto trading will
work with. 
// To add a period simply add the period to the existiung PArmList separated by
a comma AND then add an interval test to the IF statement.
ChartPeriod		= ParamList("Chart Period", "1,3,5,7,10,15,20,30,Hour,Day", 2);	//
chart period muyst agree with this setting for auto trading to work
if( ( Interval() == 60    		AND ChartPeriod == "1" )  		OR 
	( Interval() == 60 * 3   	AND ChartPeriod == "3" ) 		OR
	( Interval() == 60 * 5   	AND ChartPeriod == "5" ) 		OR
	( Interval() == 60 * 7   	AND ChartPeriod == "7" ) 		OR
	( Interval() == 60 * 10		AND ChartPeriod == "10" ) 		OR 
	( Interval() == 60 * 15   	AND ChartPeriod == "15" ) 		OR
	( Interval() == 60 * 20   	AND ChartPeriod == "20" ) 		OR
	( Interval() == 60 * 30   	AND ChartPeriod == "30" ) 		OR
	( Interval() == inHourly 	AND ChartPeriod == "Hour" ) 	OR  
	( Interval() == inDaily		AND ChartPeriod == "Day" ) 		)  IntervalOK = True; 
else IntervalOK = False;

pContracts			= Param("Contracts", 1, 1, 1000, 1);								// definethe default
number of contracts to order
OrderType			= ParamList("Order type", "STP,LMT,MKT");							// select type of
ofder to send
tick 				= Param("STP order width", 0, 0.0, 10.0, 0.1);					// amount from
current price the stop order will be set

// The symbol on the chart must agree with the symbol selected from this list
before AutoTrading will connect to TWS
// Note on modifyin this. The symbol must match exactly what is in the AB
symbol directory. 
// You can see below that ZG has spaces and the exact number of spaces is
required. 
// To add a new line just copy a line and replace the things between the "..."
with the new symbol.
// The last line ends with "); and that is required so don't mess it up.
// To change the ticker list you may remove a line but refer to ParamList if
you have trouble. The spacing has to be exactly what the AB database has.
// The ticker list is a string separated by commas. If you separate them so
they fit on another line you must close the string, add a + to indicate
// the string continues on the next line. The string must be closed with a "
and the ParamList must be closed with a );

sTicker	= ParamList("Symbol to trade", 
	"TFZ8-NYBOT-FUT," +
	"DXZ8-NYBOT-FUT," +
	"NDZ8-NYBOT-FUT," +
	"NQZ8-NYBOT-FUT," +
	"ESZ8-GLOBEX-FUT," +
	"ZG   AUG 08-ECBOT-FUT," +
	"EUR.USD-IDEALPRO-CASH," + 
	"IWM-ISLAND-STK," + 
	"TWM,UWM," + 
	"QID,QLD,QQQQ"); 

Pause				= ParamToggle("Pause trading", "Run|Pause");		// pause trading
ManualBuy			= ParamTrigger("Manual buy", "Buy");								// allows user to buy
the default number of contracts
ManualSell			= ParamTrigger("Manual Sell", "Sell");							// allows user to
sell the default number of contracts
CancelAll 			= ParamTrigger("Cancel all pending orders", "Cancel all");		//
user can cancel all orders that have not been filled
CloseAll 			= ParamTrigger("Close all", "Close all");							// cancel all
pending orders and close all open positions

Reset 				= ParamTrigger("Reset", "Reset");									// resets the auto trading
variables 

StaticVarSet(VarPfx + "AutoTrading", pAutoTrading );

//
##############################################################################################################################################################
//
##############################################################################################################################################################
// ###############      Initilization      Initilization       Initilization   
   Initilization       Initilization    
######################################## 
//
##############################################################################################################################################################
//
##############################################################################################################################################################

sysTime = Now(4);	// time offset from New York
sysTimeStr = 	NumToStr(SysTime, 1.0, False);
barTime = TimeNum();

 
// initializes the static variables when the program starts and when the user
presses Reset.
if (Reset OR Nz(StaticVarGet(VarPfx + "SystemInitialized"), True)) // init
static vars when indicator starts
 {
	StaticVarSet(VarPfx + "SystemInitialized", True);
//	pause = True;	// used to artifically pause the system on init. 

	// initialize auto trading vars
	StaticVarSet(VarPfx + "OrderState", 0); 				// contains the order state being
processed, normal is none
	StaticVarSetText(VarPfx + "ordID", "");		 		// an active order being
processed, blank when no orders are active
	StaticVarSet(VarPfx + "GetStatus", False);			// a flag informs the program
that statis is being requested for an active order
	StaticVarSet(VarPfx + "WaitForConfirm",  False);	// waiting for the number of
contracts to agree with the order that was placed 
	StaticVarSetText(VarPfx + "EOD", ""); 				// 	used to control order processing
at the close of trading hours
} // end of power up or reset initialize

// make variables available to the system and trading code
OrderState 		= StaticVarGet(VarPfx + "OrderState"); 		// the current order
state
numPositions 		= Nz(StaticVarGet(VarPfx + "numPositions"));	// the number of
positions currently held on TWS
GetStatus 			= StaticVarGet(VarPfx + "GetStatus");			// the condition of the
status flag, true if waiting for status from TWS
ordID 				= StaticVarGetText(VarPfx + "ordID");			// ID of the order beign
processed
WaitForConfirm 	= StaticVarGet(VarPfx + "WaitForConfirm");	// flag used to tell
the program to wait for TWS to update the number of positions
LastC 				= LastValue(Close); 								// this is the last tick that was
received from the broker data feed 
errorMsg 			= "None";											// used to hold the TWS error message

//
##############################################################################################################################################################
//
##############################################################################################################################################################
// ################################     Functions     Functions     Functions  
  Functions     Functions     Functions   
######################################
//
##############################################################################################################################################################
//
##############################################################################################################################################################

// assign values to the following constants
// trigger states used by the program
fNone 		= 0; // no orders are being processed
mCancel 	= 1; // the user has manually selected cancel all open orders
mClose 	= 2; // the user has manually selected close all trades
mBuy 		= 3; // the user has manually placed a buy order
mSell 		= 4; // theuser has manually placed a sell order
pBuy 		= 5; // the users system has generated a buy order 
pSell 		= 6; // the users system has generated a sell order 
pShort 	= 7; // the users system has generated a short order 
pCover 	= 8; // the users system has generated a cover order

// order states set by the program
ordNone 		= 20; 	// there are no open orders being processed
ordCancelBuy 	= 21;	// an open buy order is being cancelled and is waiting for
a "Cancelled" status from TWS 
ordCancelSell	= 22;	// an open sell order is being cancelled and is waiting for
a "Cancelled" status from TWS  
ordSell 		= 23;	// an open sell order is being processed and is waiting for a
"Filled" status from TWS   
ordBuy 		= 24;	// an open buy order is being processed and is waiting for a
"Filled" status from TWS    
ordCover 		= 25;	// an open cover order is being processed and is waiting for a
"Filled" status from TWS    
ordShort 		= 26;	// an open short order is being processed and is waiting for a
"Filled" status from TWS    
ordCancelAll 	= 27;	// a cancel all order is being processed and is waiting for
a "Cancelled" status from TWS    
ordCloseAll 	= 28; 
ordManBuy 		= 29;	// a manual buy order is being processed and is waiting for a
"Filled" status from TWS    
ordManSell 	= 30;	// a manual sell order is being processed and is waiting for
a "Filled" status from TWS    

// converts the trade states to displayable text
function fCvtState(s) // conberts the states to strings for file or trace
{
	temp = "";
	// prog trigger states 
	if(s==fNone) 					temp = "NoTrigger"; 
	else if(s==pBuy) 				temp = "ProgBuy"; 
	else if(s==pSell) 			temp = "ProgSell"; 
	else if(s==pShort) 			temp = "ProgShort"; 
	else if(s==pCover) 			temp = "ProgCover"; 
	// order states
	else if(s==ordNone) 			temp = "OrdNone"; 
	else if(s==ordBuy) 			temp = "OrdBuy"; 
	else if(s==ordSell) 			temp = "OrdSell"; 
	else if(s==ordShort) 		temp = "OrdShort"; 
	else if(s==ordCover) 		temp = "OrdCover"; 
	else if(s==ordCancelBuy) 	temp = "OrdCancelBuy"; 	
	else if(s==ordCancelSell) 	temp = "OrdCancelSell"; 
	else if(s==ordCancelAll) 	temp = "OrdCancelAll"; 
	else if(s==ordCloseAll) 	temp = "OrdCloseAll"; 
	else if(s==ordManBuy) 		temp = "ordManBuy";
	else if(s==ordManSell) 		temp = "OrdManSell"; 
	// manual triggers
	else if(s==mCancel) 			temp = "Cancel"; 
	else if(s==mClose) 			temp = "CloseAll"; 
	else if(s==mBuy) 				temp = "ManBuy"; 
	else if(s==mSell) 			temp = "ManSell"; 
	// error state
	else 
	{ 
		temp = "Invalid state"; 
		if(DebugOn) _TRACE("#, Invalid state=" + NumToStr(s, 1.0)); 
	}
	return temp;
}

// take hhmmss string and convert to hh:mm:ss
function fFormatTime(time) 
{
	tFmt = "";
	Len = StrLen(time);
	if(Len == 5) tFmt = StrLeft(time,1) + ":" + StrMid(time,1,2) + ":" +
StrRight(time, 2); 
	else tFmt = StrLeft(time,2) + ":" + StrMid(time,2,2) + ":" + StrRight(time,
2); 
	return tFmt;
}

// this handles the errors returned on the GetStatus command. 
function fErrorProcessor(msg)
{
	msgid = "";
	if(StrLeft(msg, 2) == "ID")
	{
		offset1 = StrFind(msg, "Error ");
		temp = StrMid(msg, offset1 + 5, offset1 + 5);
		Offset2 = StrFind(temp, ".");
		msgid = StrLeft(temp, Offset2 - 1); 
		if(DebugOn) 	_TRACE("#, ErrorMessage = " + msgid);
	}
	return msgid;
}


if(DebugOn) 	_TRACE("#, Post Init A, Positions=" + NumToStr(StaticVarGet(VarPfx
+ "numPositions"), 1.0) + 
	", GetStatus=" + NumToStr(GetStatus, 1.0) + ", OrderState=" +
fCvtState(OrderState) + ", OrderID=" + ordID + 
	", WaitForConfirm=" + NumToStr(WaitForConfirm, 1.0)); 

_SECTION_END(); 

//
##############################################################################################################################################################
//
##############################################################################################################################################################
// ###################    Trading system indicators      			Trading system
indicators      			Trading system indicators         #####################
// ###################    This section of the code uses AB indicators to define
the trade timing.                                          
#####################
//
##############################################################################################################################################################
//
##############################################################################################################################################################
_SECTION_BEGIN("System"); 

//
##############################################################################################################################################################
// ################  System Parameters
//
##############################################################################################################################################################
Buy = Sell = Short = Cover = 0; // make sure all arrays are set empty

//
##############################################################################################################################################################
// ################  Signal calculations - add your indicator and calculations
here
//
##############################################################################################################################################################

pWMA1 	= Param("WMA 1 period", 6, 1, 20, 1);
pWMA2 	= Param("WMA 2 period", 7, 1, 20, 1);
fMA1 	= WMA(C, pWMA1);	// calculate MA 1
fMA2 	= WMA( (Open + Close)/2, pWMA2);	// original


Buy				= Cross(fMA1, fMA2); 
Short			= Cross(fMA2, fMA1);  
Sell			= Short;
Cover 			= Buy; 

//
##############################################################################################################################################################
//
##############################################################################################################################################################
// #####################    PLOT INDICATORS    PLOT INDICATORS    PLOT
INDICATORS     PLOT INDICATORS     PLOT INDICATORS     
##################################
// #####################    	Change the following lines to display your system
as you see fit.										##################################
//
##############################################################################################################################################################
//
##############################################################################################################################################################

Plot(C, 	 "", colorBlack, ParamStyle( "Price Style", styleBar, maskPrice ) );
Plot(fMA1, "\nMA1(" + NumToStr(pWMA1, 1.0) + ")", colorRed);					// plot the MA
lines
Plot(fMA2, "\nMA2(" + NumToStr(pWMA2, 1.0) + ")", colorRed,  styleDashed);	//
plot the MA lines

PlotShapes(Buy 	* shapeUpArrow, 			colorGreen, 	0, L, -5 );
PlotShapes(Sell 	* shapeDownArrow, 		colorRed, 		0, H, -5 );
PlotShapes(Short * shapeHollowDownArrow,	colorRed, 		0, H, -20 );
PlotShapes(Cover * shapeHollowUpArrow, 	colorGreen, 	0, L, -20 );

_SECTION_END(); 

_SECTION_BEGIN(SectionName + "AT"); // Dont change anything in this section
unless you know exactly what you are doing.

//
##############################################################################################################################################################
// ################  DO NOT CHANGE THE NEXT 4 LINES -- last values changes the
array signal to a binary signal to provide a trigger for the auto trade logic
//
##############################################################################################################################################################

// displays the signal value in the interpretation window
printf("\nBuy = " 	+ NumToStr(Buy, 1.0) + 
		"  Sell = " 	+ NumToStr(Sell,  1.0) + 
		"  Short = " 	+ NumToStr(Short, 1.0) + 
		"  Cover = " 	+ NumToStr(Cover, 1.0) + "\n");

BuyInd 	= LastValue(Buy);		// convert the buy signal to a pulse used by the
trading logic
ShortInd  	= LastValue(Short);	// convert the short signal to a pulse used by
the trading logic
SellInd 	= LastValue(Sell);	// convert the sell signal to a pulse used by the
trading logic	
CoverInd	= LastValue(Cover);	// convert the cover signal to a pulse used by the
trading logic

if(DebugOn) 	_TRACE("#, Indicators 2, Static, BuyInd = " + NumToStr(BuyInd,
1.0) + 
			", SellInd = " 	+ NumToStr(SellInd,  1.0) + 
			", ShortInd = " 	+ NumToStr(ShortInd, 1.0) + 
			", CoverInd = " 	+ NumToStr(CoverInd, 1.0) );

//
##############################################################################################################################################################
//
##############################################################################################################################################################
// ######################################      MANUAL BUY      MANUAL BUY   
MANUAL BUY     MANUAL BUY      MANUAL BUY       
###################################
//
##############################################################################################################################################################
//
##############################################################################################################################################################

function fManBuyPositions(ib, oState, OID, positions)	
{
	if(DebugOn) 	_TRACE("#, ManBuy top, positions=" + NumToStr(positions, 1) + ",
contracts=" + NumToStr(pContracts, 1));    
	newState = oState; 
	// this function closes all open trades
	orderID = "";
	orderID = ib.PlaceOrder(sTicker, "Buy", pContracts, "MKT", 0, 0, "GTC", True,
10, "outsideRTH");
	if(orderID != "")
	{
		ordType = "ManBuy";
		newState = ordManBuy; 
		StaticVarSet(VarPfx + "TargetPositions", positions + pContracts);
		StaticVarSetText(VarPfx + "ordID", orderID );
		StaticVarSet(VarPfx + "GetStatus", True);
		StaticVarSet(VarPfx + "WaitForConfirm",  True); 
		if(DebugOn) 	_TRACE("#, ManBuy " + ordType + ", " + fFormatTime(sysTimeStr) +
", OrderID" + orderID  + ", OrderState=" + fCvtState(newState) + 
			", Close=" + NumToStr(LastValue(Close), 1.2));  
	}
	return newState; // return the type of order that was made
}

//
##############################################################################################################################################################
//
##############################################################################################################################################################
// #################################    MANUAL  SELL     MANUAL  SELL    
MANUAL  SELL     MANUAL  SELL     MANUAL  SELL     
###################################
//
##############################################################################################################################################################
//
##############################################################################################################################################################

function fManSellPositions(ib, oState, OID, positions) // we are neither long
or short
{
	if(DebugOn) 	_TRACE("#, ManSel1 top, positions=" + NumToStr(positions, 1) + ",
contracts=" + NumToStr(pContracts, 1));    
	newState = oState; 
	orderID  = "";
	orderID  = ib.PlaceOrder(sTicker, "SELL", pContracts, "MKT", 0, 0, "GTC",
True, 10, "outsideRTH");
	if(orderID  != "")
	{
		ordType = "ManSell";
		newState = ordManSell; 
		StaticVarSet(VarPfx + "TargetPositions", positions - pContracts);
		StaticVarSetText(VarPfx + "ordID", orderID);
		StaticVarSet(VarPfx + "GetStatus", True);
		StaticVarSet(VarPfx + "WaitForConfirm",  True); 
		if(DebugOn) 	_TRACE("#, ManSel1, " + ordType + ", Time=" +
fFormatTime(sysTimeStr) + ", OrderID=" + orderID + 
			", OrderState=" + fCvtState(newState) + ", Close=" +
NumToStr(LastValue(Close), 1.2));    
	}
	return newState; // return the type of order that was made
}

//
##############################################################################################################################################################
//
##############################################################################################################################################################
// ######################################    CANCEL   		CANCEL   		CANCEL  
		CANCEL   		CANCEL   		CANCEL    ######################################
//
##############################################################################################################################################################
//
##############################################################################################################################################################
 
function fCancelPositions(ib, oState, OID, positions)	 // we are neither long
or short
// trigger - trg defines the type of order
{
	newState = oState; 
	// this if statement prevents making multiple orders - subsequent orders are
ignored
	if( oState == ordSell OR oState == ordShort)
	{
		if(OID != "") // used to cancel a sell order that has not been filled  
		{
			newState = ordCancelSell;
			ordType = "CancelSell";
			ib.CancelOrder(OID); 
			StaticVarSet(VarPfx + "GetStatus", True);
			if(DebugOn) 	_TRACE("#, Cancel 1, " + ordType + ", Time=" +
fFormatTime(sysTimeStr) + ", OrderState =" + fCvtState(newState) + 
				", OrderID=" + OID);    
		}
	}
	else if(oState == ordBuy OR oState == ordCover)
	{
		if(OID != "") // used to cancel a buy order that has not been filled
		{
			newState = ordCancelBuy;
			ordType = "CancelBuy";
			ib.CancelOrder(OID); 
			StaticVarSet(VarPfx + "GetStatus", True);
			if(DebugOn) 	_TRACE("#, Cancel 2, " + ordType + ", Time=" +
fFormatTime(sysTimeStr) + ", OrderState=" + fCvtState(newState) + 
				", OrderID=" + OID);    
		}
	}
	return newState; // return the type of order that was made
}

//
##############################################################################################################################################################
//
##############################################################################################################################################################
// ######################################      BUY      BUY      BUY      BUY  
   BUY      BUY      BUY     
###################################################
//
##############################################################################################################################################################
//
##############################################################################################################################################################
 
function fBuyPositions(ib, oState, OID, positions)	 // we are neither long or
short
// trigger - trg defines the type of order
{
	newState = oState; 
	price = tick  + LastC;
	// this if statement prevents making multiple orders - subsequent orders are
ignored
 	if( oState == ordNone AND OID == "")	// program trade and no open positions
or pending order sent
	{
		orderID = "";
		if(OrderType == "MKT") orderID = ib.PlaceOrder(sTicker, "BUY",  pContracts,
"MKT", 0, 0, "GTC", True, 10, "outsideRTH");
		if(OrderType == "STP") orderID = ib.PlaceOrder(sTicker, "BUY",  pContracts,
"STP", 0, price, "GTC", True, 10, "outsideRTH");
		if(OrderType == "LMT") orderID = ib.PlaceOrder(sTicker, "BUY",  pContracts,
"LMT", price, 0, "GTC", True, 10, "outsideRTH");
		if(orderID != "")
		{
			ordType = "ProgBuy";
			newState = ordBuy;
			StaticVarSetText(VarPfx + "ordID", orderID);
			StaticVarSet(VarPfx + "GetStatus", True);
			StaticVarSet(VarPfx + "WaitForConfirm",  True); 
			if(DebugOn) 	_TRACE("#, Buy, " + ordType + ", Time" +
fFormatTime(sysTimeStr) + ", OrderState=" + fCvtState(newState) +  
				", OrderID=" + orderID  + 	", Price=" + NumToStr(LastC, 1.2));  
		}
	}
	return newState; // return the type of order that was made
}
      
//
##############################################################################################################################################################
//
##############################################################################################################################################################
// #################################    SHORT     SHORT     SHORT     SHORT    
SHORT   
########################################################################
//
##############################################################################################################################################################
//
##############################################################################################################################################################

function fShortPositions(ib, oState, OID, positions) // we are neither long or
short
{
	newState = oState; 
	price = LastC - tick;
	if( oState == ordNone AND OID == "") 		// no sell order sent and no position
and no current order
	{
		orderID = "";
		if(OrderType == "MKT") orderID = ib.PlaceOrder(sTicker, "SELL", pContracts,
"MKT", 0, 0, "GTC", True, 10, "outsideRTH");
		if(OrderType == "STP") orderID = ib.PlaceOrder(sTicker, "SELL", pContracts,
"STP", 0, price, "GTC", True, 10, "outsideRTH");
		if(OrderType == "LMT") orderID = ib.PlaceOrder(sTicker, "SELL", pContracts,
"LMT", price, 0, "GTC", True, 10, "outsideRTH");
		if(orderID != "")
		{
			ordType = "ProgShort";
			newState = ordShort;
			StaticVarSetText(VarPfx + "ordID", orderID);
			StaticVarSet(VarPfx + "GetStatus", True);
			StaticVarSet(VarPfx + "WaitForConfirm",  True); 
			if(DebugOn) 	_TRACE("#, Short, " + ordType + ", Time=" +
fFormatTime(sysTimeStr) + ", OrderState=" + fCvtState(newState) + 
				", OrderID=" + orderID + ", Price=" + NumToStr(price, 1.2));    
		}
	}
	return newState; // return the type of order that was made
}

//
##############################################################################################################################################################
//
##############################################################################################################################################################
// #################################    SELL     SELL     SELL     SELL    
SELL      SELL     SELL    
#########################################################
//
##############################################################################################################################################################
//
##############################################################################################################################################################

function fSellPositions(ib, oState, OID, positions) // we are neither long or
short
{
	newState = oState; 
	if( oState == ordNone ) // close a long position
	{
		// exit the current position with a market order
		orderID = "";
		orderID = ib.PlaceOrder(sTicker, "SELL", abs(positions), "MKT", 0, 0, "GTC",
True, 10, "outsideRTH");
		ordType = "ProgSell";
		newState = ordSell;
		StaticVarSetText(VarPfx + "ordID", orderID);
		StaticVarSet(VarPfx + "GetStatus", True);
		StaticVarSet(VarPfx + "WaitForConfirm",  True); 
		if(DebugOn) 	_TRACE("#, Sell, " + ordType + ", Time=" +
fFormatTime(sysTimeStr) + ", OrderState=" + fCvtState(newState) + 	
			", OrderID=" + orderID + 	", Close=" + NumToStr(LastValue(Close), 1.2));   

	}
	return newState; // return the type of order that was made
}

//
##############################################################################################################################################################
//
##############################################################################################################################################################
// ################################    COVER      COVER      COVER      COVER  
   COVER      COVER      COVER    
##############################################
//
##############################################################################################################################################################
//
##############################################################################################################################################################

function fCoverPositions(ib, oState, OID, positions)	 // we are neither long or
short
{
	newState = oState; 
	if( oState == ordNone ) // program cover and go flat
	{
		orderID = "";
		orderID = ib.PlaceOrder(sTicker, "BUY", abs(positions), "MKT", 0, 0, "GTC",
True, 10, "outsideRTH");
		ordType = "progCover";
		newState = ordCover;
		StaticVarSetText(VarPfx + "ordID", orderID); 
		StaticVarSet(VarPfx + "GetStatus", True);
		StaticVarSet(VarPfx + "WaitForConfirm",  True); 
		if(DebugOn) 	_TRACE("#, Cover, " + ordType + ", Time=" +
fFormatTime(sysTimeStr) + ", OrderState=" + fCvtState(newState) + 	
			", OrderID=" + orderID + 	", Close=" + NumToStr(LastValue(Close), 1.2));   

	}
	return newState; // return the type of order that was made
}
 

//
##############################################################################################################################################################
//
##############################################################################################################################################################
// ############	 Order Precessing Loop	 Order Precessing Loop	 Order Precessing
Loop	 Order Precessing Loop	 Order Precessing Loop   #######################
//
##############################################################################################################################################################
//
##############################################################################################################################################################

if( StaticVarGet(VarPfx + "AutoTrading") == True AND // auto trading parameter
is set on
	IntervalOK AND 		// chart is the same interval as the Chart period selected 
	sTicker == Name() ) 	// the chart symbol is the same as the ticker parameter
{
	ibc = GetTradingInterface("IB");
	ConnectedStatus = ibc.IsConnected();	// get the connection status, 2 is OK

	// the foloowing code closes trades at the end of the day.
	// it does this in steps. 1) cancels all open orders. 2) Closes all positions.
3) resets the control var EOD
	EodVar = StaticVarGetText(VarPfx + "EOD"); 
	if(sysTime == closeTime + 1 AND EodVar == "") // this is the close time
parameter + 1 seconds 
	{
		ibc.CancelAllPendingOrders(); 
		StaticVarSetText(VarPfx + "EOD", "Cancel");
		_TRACE("#, #####  CancelAll end of day  #####"); 		
	}

	if(sysTime == closeTime + 5 AND EodVar == "Cancel") // this is the close time
parameter + 5 seconds 
	{
		ibc.CloseAllOpenPositions();
		StaticVarSetText(VarPfx + "EOD", "Close");
		_TRACE("#, #####  CloseAll end of day  #####"); 		
	}

	if(sysTime == closeTime + 8 AND EodVar == "Close") // this is the close time
parameter + 8 seconds 
	{
		ibc.CloseAllOpenPositions();
		StaticVarSetText(VarPfx + "EOD", "");
		_TRACE("#, *****  Reset EOD static var  *****"); 		
	}
	// end of close trades at ene of day

	// this is where the trade processing is done
	if( sysTime < closeTime AND (ConnectedStatus == 2 OR ConnectedStatus == 3) )
// connected to TWS with no error messages
	{
		if(StaticVarGet(VarPfx + "SystemInitialized") ==  True)
		{
			StaticVarSet(VarPfx + "SystemInitialized", False);  
			ibc.CancelAllPendingOrders(); // cancel any open orders on start or reset
		}

		// retrieve static variables
		numPositions  = ibc.GetPositionSize(sTicker); 
		StaticVarSet(VarPfx + "numPositions", numPositions);

		if(DebugOn) 	_TRACE("#, SysLoop 0, Positions=" + NumToStr(StaticVarGet(VarPfx
+ "numPositions"), 1.0) + 
			", GetStatus=" + NumToStr(GetStatus, 1.0) + ", OrderState=" +
fCvtState(OrderState) + ", OrderID=" + ordID + 
			", WaitForConfirm=" + NumToStr(WaitForConfirm, 1.0) + "\n" ); 

		// GetStaus = false indicates TWS has completed processing the order
		// Wait for the trade to be confirmed by a change in the number of positions
before resetting the order state and waitforconfirm flag
		// this is used to prevent placing an order if the signal is still active
after a filled status from TWS
		if(WaitForConfirm AND !GetStatus)
		{
			if(DebugOn) 	_TRACE("#, WaitForConfirm, OrderState = " +
fCvtState(OrderState) + "\n"); 
			// note: WaitForConfirm set false if order cancelled, see GetStatus
Cancelled logic
			if(	(OrderState == OrdBuy 	AND numPositions > 0) 	OR 
				(OrderState == OrdShort AND numPositions < 0) 	OR
				(OrderState == OrdCover AND numPositions == 0) 	OR 
				(OrderState == OrdSell 	AND numPositions == 0) 	)
			{		
				if(DebugOn) 	_TRACE("#, Program trade WaitForConfirm complete"); 
				OrderState = ordNone; StaticVarSet(VarPfx + "OrderState", OrderState);
				WaitForConfirm = False; StaticVarSet(VarPfx + "WaitForConfirm",  False); 
			}
			// user made a manual order so wait for the number of positions to indicate
the purchase before resetting order state and waitforconfirm flags
			else if(OrderState == ordManBuy OR OrderState == ordManSell)
			{
				if(DebugOn) 	_TRACE("#, Manual trade processed, target positions=" +
NumToStr(StaticVarGet(VarPfx + "TargetPositions"), 1.0)); 
				if( numPositions  == StaticVarGet(VarPfx + "TargetPositions"))	
				{
					OrderState = ordNone; StaticVarSet(VarPfx + "OrderState", OrderState);
					StaticVarSet(VarPfx + "WaitForConfirm",  False); 
					StaticVarSet(VarPfx + "TargetPositions", 0);
				}
			}
			// user requested close all positions so wait for the number of positions to
indicate all positions are closed before resetting 
			// order state AND waitforconfirm flags
			else if(OrderState == ordCloseAll ) 
			{
				if(numPositions  == 0) 
				{
					if(DebugOn) 	_TRACE("#, Close all processed"); 
					OrderState		= ordNone; 	StaticVarSet(VarPfx + "OrderState", OrderState);
					ordID = ""; StaticVarSetText(VarPfx + "ordID", "");
					StaticVarSet(VarPfx + "GetStatus", False); 
					StaticVarSet(VarPfx + "WaitForConfirm",  False); 
				}
			}	// end close all
		}
	
		//
##############################################################################################################################################################
		// ###################    Trigger Control    Trigger Control    Trigger
Control    Trigger Control    Trigger Control    Trigger Control  
######################
		// ###################    This section takes the indicator timing and
converts it to one shot triggers required for orders.               
######################
		//
##############################################################################################################################################################

		// waitforconfirm and getstatus flags are used to prevent multiple orders
while a current order is being processed
		// orders are onluy allowed if the waitforconfirm and getstatus flags are
false

		BuyTrigger = SellTrigger = ShortTrigger = CoverTrigger = False;
		if(DebugOn) 	_TRACE("#, AllowInd 0, Indicator, Buy=" + NumToStr(BuyInd, 1.0)
+ ", Sell=" + NumToStr(SellInd, 1.0) + 
			", Short=" + NumToStr(ShortInd, 1.0) + ", Cover=" + NumToStr(CoverInd,
1.0));
		if(!WaitForConfirm AND !GetStatus  ) // allow indicators to pass unless a
trade to being processed
		{
			// This is sequence sensitive. cover and sell should close positions before
new positions are taken.
			// **********  CAUTION *****************
			// but note that if your system does not generate the sell and cover signals
the order process can hang and not allow trades
			// Pause parameter blocks all programmed trading 
			if( numPositions > 0 AND SellInd AND !Pause) // sell is only allowed when
there are a positive number of positions
			{
				SellTrigger = True; 
				if(DebugOn) 	_TRACE("#, AllowInd 1 Sell trigger"); 
			}
			else if( numPositions < 0 AND CoverInd AND !Pause) // cover is only allowed
when there are a negative number of positions
			{
				CoverTrigger = True;  
				if(DebugOn) 	_TRACE("#, AllowInd 2 Cover trigger"); 
			}
			else if( !Pause AND numPositions == 0 ) // buy and short is only allowed
when there are no positions
			{
				if(BuyInd ) 
				{
					BuyTrigger = True; 
					if(DebugOn) 	_TRACE("#, AllowInd 3, Buy trigger"); 
				}
				else if(ShortInd ) 
				{
					ShortTrigger = True; 
					if(DebugOn) 	_TRACE("#, AllowInd 4, Short trigger"); 
				}
			}
		} // end allowIndicators 

		// signal reversal and we have open an order and the trend changes direction
		else if ( WaitForConfirm AND numPositions == 0) // Reversal signal with an
open order
		{
			if(DebugOn) 	_TRACE("#, Reversal Cancel 0");
			if( (OrderState == ordBuy OR OrderState == ordCover ) AND SellInd) 
			{
				SellTrigger   = True; 
				OrderState == OrdNone;  StaticVarSet(VarPfx + "OrderState",  OrdNone); 
				WaitForConfirm = False; StaticVarSet(VarPfx + "WaitForConfirm",  False); 
				if(DebugOn) 	_TRACE("#, Reversal Cancel 1, SellTrigger=" +
NumToStr(SellTrigger, 1.0));
			}
			else if( (OrderState == ordShort OR OrderState == ordSell ) AND CoverInd ) 
			{
				CoverTrigger  = True; 
				OrderState == OrdNone;  StaticVarSet(VarPfx + "OrderState",  OrdNone); 
				WaitForConfirm = False; StaticVarSet(VarPfx + "WaitForConfirm",  False); 
					if(DebugOn) 	_TRACE("#, Reversal Cancel 2, CoverTrigger=" +
NumToStr(CoverTrigger, 1.0));
			}
		}
		if(DebugOn) 	_TRACE("#, AllowInd End, Buy=" + NumToStr(BuyTrigger, 1.0) + ",
Sell=" + NumToStr(SellTrigger, 1.0) + 
				", Short=" + NumToStr(ShortTrigger, 1.0) + ", Cover=" +
NumToStr(CoverTrigger, 1.0));

		//
#################################################################################################################################################
		// ########    Stateless processes      Stateless processes      Stateless
processes      Stateless processes    Stateless processes    ############
		//
#################################################################################################################################################
		if(CancelAll)
		{
			ibc.CancelAllPendingOrders(); 
			OrderState = ordNone; StaticVarSet(VarPfx + "OrderState", OrderState);
			ordType = "CancelAll";
			StaticVarSet(VarPfx + "WaitForConfirm",  False); 
			StaticVarSet(VarPfx + "GetStatus",  False); 
			if(DebugOn) 	_TRACE("#, Trigger CancelAll, OrderState=" +
fCvtState(OrderState) + ", OrderID=" + ordID); 
			ordID = ""; StaticVarSetText(VarPfx + "ordID", "");
		}
		else if(CloseAll )
		{
			// close all positions
			ibc.CancelAllPendingOrders(); 
			ibc.CloseAllOpenPositions();
			OrderState = ordCloseAll; StaticVarSet(VarPfx + "OrderState", OrderState );
			ordType = "CloseAll";
			StaticVarSet(VarPfx + "GetStatus",  True); 
			StaticVarSet(VarPfx + "WaitForConfirm",  True); 
			if(DebugOn) 	_TRACE("#, *****  Trigger CloseAll " + ordID + ", OrderState="
+ fCvtState(OrderState) + 
				", SysTime =" + NumToStr(SysTime, 1.0, False) + "  ****"); 
		}
		else if(!GetStatus AND ManualBuy)	// manual  buy the number of contracts
defined in pContracts			
		{ 
			state = fManBuyPositions(ibc, OrderState, ordID, numPositions); 	
			StaticVarSet(VarPfx + "OrderState", state); 
		}
		else if(!GetStatus AND ManualSell)	// manual sell number of contracts defined
in pContracts
		{ 
			state = fManSellPositions(ibc, OrderState, ordID, numPositions); 	
			StaticVarSet(VarPfx + "OrderState", state); 
		}

		//
#################################################################################################################################################
		//
#################################################################################################################################################
		// ##########      Program Trading         Program Trading       Program
Trading        Program Trading       Program Trading      #################
		// ##########      Note that the order is sequence sensitive as sell and
cover should be processed before buy and short.		    #################
		//
#################################################################################################################################################
		//
#################################################################################################################################################
		else if(!WaitForConfirm ) // not waiting for a trade to settle
		{
			if( SellTrigger AND numPositions > 0) // sell to go flat
			{
				state = fSellPositions(ibc, OrderState, ordID, numPositions); 	
				OrderState = state; StaticVarSet(VarPfx + "OrderState", state); 
				if(DebugOn) 	_TRACE("#, Trigger ordSell, OrderState=" + fCvtState(state));

			}
			else if( CoverTrigger AND numPositions < 0) // buy to go flat
			{
				state = fCoverPositions(ibc, OrderState, ordID, numPositions); 	
				OrderState = state; StaticVarSet(VarPfx + "OrderState", state); 
				if(DebugOn) 	_TRACE("#, Trigger ordCover, OrderState=" + fCvtState(state));

			}
			else if( BuyTrigger )
			{
				state = OrderState;
				if(numPositions == 0)	// buy n contracts
					state = fBuyPositions(ibc, OrderState, ordID, numPositions); 	
				else if(numPositions < 0) // close short position first then go long after
filled 
					state = fCoverPositions(ibc, OrderState, ordID, numPositions); 
				OrderState = state; StaticVarSet(VarPfx + "OrderState", state); 
				if(DebugOn) 	_TRACE("#, Trigger ordBuy, OrderState=" + fCvtState(state)); 
			}
			else if( ShortTrigger )
			{
				state = OrderState;
				if(numPositions == 0)	// sell n contracts
					state = fShortPositions(ibc, OrderState, ordID, numPositions); 	
				else if(numPositions > 0) // close long first then go short after filled
					state = fSellPositions(ibc, OrderState, ordID, numPositions); 	
				OrderState = state; StaticVarSet(VarPfx + "OrderState", state); 
				if(DebugOn) 	_TRACE("#, Trigger ordShort, OrderState=" + fCvtState(state));

			}
		}

		//
#################################################################################################################################################
		//
#################################################################################################################################################
		// ##########      Order Status Processing     Order Status Processing    
Order Status Processing     Order Status Processing     #################
		//
#################################################################################################################################################
		// ###  order states 	ordNone = 20; ordCancelBuy = 21; ordCancelSell = 22;
ordSell = 23; ordBuy = 24; ordCover = 25; ordShort = 26; 
		// ###  					ordCancelAll = 27; ordCloseAll = 28; ordManBuy = 29; ordManSell
= 30;
		//
#################################################################################################################################################
		//
#################################################################################################################################################
		ordID = StaticVarGet(VarPfx + "ordID");
		if(DebugOn) 	_TRACE("#, OrdState 0, GetStatus=" + NumToStr(GetStatus, 1.0) +
", Positions=" + NumToStr(numPositions, 1.0) + 
			", OrderState=" + fCvtState(OrderState) + ", OrderID=" + ordID + ", Time=" +
fFormatTime(sysTimeStr)); 
		// process the status messages after an order has been sent or cancelled
		tempStatus = "None";
		if(GetStatus)
		{
			tempStatus = ibc.GetStatus( ordID, True ); 	// get order status 
			if(tempStatus == "Filled")
			{
				// make sure the numPositions is true for the operation being conducted
				// this prevents another order as soon as this one is filled
				StaticVarSet(VarPfx + "GetStatus", False); 
				if( OrderState == ordCancelSell OR OrderState == ordCancelBuy )
				{
					OrderState = ordNone; 
					StaticVarSet(VarPfx + "OrderState", OrderState ); 
				}	
				if(DebugOn) 	_TRACE("#, OrdState 1 Filled, OrderState=" +
fCvtState(OrderState) + ", OrderID=" + ordID);
				ordID = ""; StaticVarSetText(VarPfx + "ordID", "");
			}	// end filled
			else if(tempStatus == "PreSubmitted" 	OR 
					 tempStatus == "PendingSubmit" OR 
					 tempStatus == "Pending" 		OR 
					 tempStatus == "ApiPending" 	OR 
					 tempStatus == "Submitted"		)
			{
				if( numPositions != 0 AND (OrderState == ordCancelSell OR OrderState ==
ordCancelBuy ))
				{
					OrderState = ordNone; 
					StaticVarSet(VarPfx + "OrderState", OrderState ); 
					StaticVarSet(VarPfx + "GetStatus", False); 
				}	
				if(CoverTrigger AND (OrderState == ordShort OR OrderState == ordSell))
				{
					// call Cancel to cancel the sell order and set up to reverse
					state = fCancelPositions(ibc, OrderState, ordID, numPositions); 	
					OrderState = state; StaticVarSet(VarPfx + "OrderState", state); 
					if(DebugOn) 	_TRACE("#, OrdState 2a, CancelSell, OrderState=" +
fCvtState(state)); 
				}
				else if(SellTrigger AND (OrderState == ordBuy OR OrderState == ordCover))
				{
					// call Cancel to cancel the buy order and set up to reverse
					state = fCancelPositions(ibc, OrderState, ordID, numPositions); 	
					OrderState = state; StaticVarSet(VarPfx + "OrderState", state); 
					if(DebugOn) 	_TRACE("#, OrdState 2c, CancelBuy , OrderState=" +
fCvtState(state)); 
				}
			}	// end status preSubmitted or Pending
			else if(tempStatus == "Cancelled")
			{ 
				StaticVarSet(VarPfx + "GetStatus", False); 
				StaticVarSet(VarPfx + "WaitForConfirm",  False); 
				OrderState = ordNone;   StaticVarSet(VarPfx + "OrderState", ordNone);
				if(DebugOn) 	_TRACE("#, OrdState 3 Cancel, OrderState=" +
fCvtState(OrderState) + 
						", OrderID=" + ordID + ", Positions=" + NumToStr(numPositions , 1.0) +
"\n"); 
			 	ordID = ""; StaticVarSetText(VarPfx + "ordID", "");  
			}	
			else if(tempStatus == "Error")
			{
				msg = ibc.GetLastError(0); 
				error = fErrorProcessor(msg); 
				if(DebugOn) 	_TRACE("#, OrdState 4, Error code=" + error );   
				StaticVarSet(VarPfx + "SetErrorState", True);		
				// NOTE: For error not listed below look at the message notes at the end of
the program to see how or if they were handled.
				if(error == "135" OR error == "2106" OR error == "2109") // out of normal
trading hours
				{
					StaticVarSet(VarPfx + "GetStatus", False); 
					OrderState = ordNone;   StaticVarSet(VarPfx + "OrderState", ordNone);
				 	ordID = ""; StaticVarSetText(VarPfx + "ordID", "");  
				}
				else if(error == "201")
				{
					if(OrderState == ordShort OR OrderState == ordSell)
					{
						// call Cancel to cancel the sell order and set up to reverse
						state = fCancelPositions(ibc, OrderState, ordID, numPositions); 	
						OrderState = state; StaticVarSet(VarPfx + "OrderState", state); 
					}
					else if(OrderState == ordBuy OR OrderState == ordCover)
					{
						// call Cancel to cancel the buy order and set up to reverse
						state = fCancelPositions(ibc, OrderState, ordID, numPositions); 	
						OrderState = state; StaticVarSet(VarPfx + "OrderState", state); 
					}
				}
				else 
				{ 
					if(DebugOn) 	_TRACE("#, OrdState 10 Unexpected status=" + tempstatus + ",
OrderState=" + fCvtState(OrderState) + 
						", OrderID=" + ordID); 
				}
			}	// end status error
			else 
			{ 
				if(DebugOn) 	_TRACE("#, OrdState 11 Unexpected status=" + tempstatus + ",
OrderState=" + fCvtState(OrderState) + 
					", OrderID=" + ordID); 
			}
		}	// end get status		

		if(	StaticVarGet(VarPfx + "SetErrorState") == True) 
		{
			errorMsg = ibc.GetLastError(ordID); 	
			if(errorMsg == "None" OR errorMsg == "")
				StaticVarSet(VarPfx + "SetErrorState", False); 
			else
			{
				SetChartBkColor( colorTan); 
				VisibleBars = Status( "LastVisibleBar" ) - Status( "FirstVisibleBar" );	
				instructions = "\n  Determine what the error is. Use trace if necessary.\n 
Cancel or close all orders on TWS.\n  Press Reset to continue.";		
				PlotText( "Error " + errorMsg + instructions, BarCount - VisibleBars / 2, 
					LastValue( ( HHV(H, VisibleBars) + LLV(L, VisibleBars)) / 2), colorWhite,
colorBlack);
				if(DebugOn) 	_TRACE("#, Unexpected error msg=" + errorMsg + ", OrderState="
+ fCvtState(OrderState) + ", OrdID=" + OrdID);
			}	
		}
	
		else if (Pause )
		{
			SetChartBkColor( colorLightGrey); 
			VisibleBars = Status( "LastVisibleBar" ) - Status( "FirstVisibleBar" );	
			PlotText( "######\nTrading\nPaused\n######", BarCount - VisibleBars / 2, 
				LastValue( ( HHV(H, VisibleBars) + LLV(L, VisibleBars)) / 2), colorWhite,
colorBlack);
		}
		if(ConnectedStatus == 2) stat = "Connected."; else if(ConnectedStatus == 3)
stat = "Connected with warnings.";
		if(StaticVarGet(VarPfx + "ConnectOK") == False) 
			StaticVarSet(VarPfx + "ConnectOK", True); 
		printf("\nStatus:" + 
			"\n  Symbol = " + sTicker + 
			"\n  TWS " + stat + 
			"\n  Last TWS message = " + errorMsg + 
			"\n  Order ID = " + WriteIf(ordID != "", OrdId, "None") + 
			"\n  OrderState = " + fCvtState(OrderState) + 
			"\n  Order status = " + tempStatus +
			"\n  Positions = " + NumToStr(Nz(numPositions), 1.0, False) );
	} // end is connected
	else if( ConnectedStatus == 0 OR ConnectedStatus == 1) // lost connection
	{
		// handle commection errors 
		if(ConnectedStatus == 0) stat = "Not Connected."; else if(ConnectedStatus ==
1) stat = "Lost Connection.";
		SetChartBkColor( colorYellow);		
		VisibleBars = Status( "LastVisibleBar" ) - Status( "FirstVisibleBar" );	
		PlotText( "TWS not connected. Some reasons are:\nTWS error message: " +
errorMsg + "\nIncoming connection has not been accepted.", BarCount -
VisibleBars / 2, LastValue(HHV(H, VisibleBars)), colorWhite, colorBlack);
		printf("\nTWS Status: " + stat + "\n"); 
	} // end connection error	 
	else if (sysTime > closeTime)
	{
		VisibleBars = Status( "LastVisibleBar" ) - Status( "FirstVisibleBar" );	
		PlotText( "###########\nMarket closed\n###########", BarCount - VisibleBars /
2, LastValue(HHV(H, VisibleBars)), colorWhite, colorBlack);
	}


	//
#################################################################################################################################################
	//
#################################################################################################################################################
	// ##########     
Commentary		Commentary		Commentary		Commentary		Commentary		Commentary		Commentary		Commentary		
################
	//
#################################################################################################################################################
	//
#################################################################################################################################################

} // end order processing loop
else // autotrade is off due to an error or trading is turned off
{
	// if error state, display state in title bar
	// feedback key info into title bar
	SetChartBkColor( colorPink);
	text = "\nStatus: \nAutoTrading is off. Some of the reasons are:\n" +
	" 1. Autotrading is turned off\n" +
	" 2. TWS has not been started or isn't functioning.\n" + 
	" 3. Set chart to " + sTicker + ".\n" + 
	" 4. Chart period mismatch.\n"; // end text

	printf(text);
	VisibleBars = Status( "LastVisibleBar" ) - Status( "FirstVisibleBar" );	
	PlotText(text, BarCount - VisibleBars / 2, LastValue(HHV(H, VisibleBars)),
colorWhite, colorBlack);

	if(CancelAll)
	{
		ibc = GetTradingInterface("IB");
		ibc.CancelAllPendingOrders(); 
	}
	else if(CloseAll )
	{
		// close all positions
		ibc = GetTradingInterface("IB");
		ibc.CancelAllPendingOrders(); 
		ibc.CloseAllOpenPositions();
	}
}
_SECTION_END(); 

//
#################################################################################################################################################
//
#################################################################################################################################################
// ##########       Setup and WARNINGS      Setup and WARNINGS      Setup and
WARNINGS      Setup and WARNINGS         ##############
//
#################################################################################################################################################
//
#################################################################################################################################################

// Before Auto trading will trade orders and have them filled automatically you
must register your copy of IB Controller. See File>Enter unlock code.
// if it is NOT registered the order will be sent but a T will appear on TWS
and the order will not be transmitted to the market. 
// Once IBC is registered AND the code is entered orders will be processed
automatically.

// This release level requires TWS 888.3 or above, IB.DLL of 1.8.2 or above,
and BrokerIB.exe ( IB Controller) of 1.2.1 or above.
// These are required to handle after hours trading and back filling. This
program will not work correctly unless these releases are installed.
// TWS may also require an update to JAVA. Check their site for
recommendations.

Comments: