# How to add one green/red bar confirmation into an EA?

Hello Guys,

I have created a simple RSI based EA. I would like to add one bar confirmation in it.

For example, lets say that if EA would take a "BUY" trade when RSI is 60.....then instead of taking a trade right away.......EA should wait for one more candle and if it is also green then only EA should take a "BUY" trade. (And vice-versa for Short trades)

I am attaching my EA code below. It would be great if anyone could explain me how to do it or redirect me to some tutorial link.

thanks :)

```#include <Trade\Trade.mqh>
input int MagicNumber=1247;
input double StopLoss=20;
input double TakeProfit=50;
input int TrailingStop=
10 ;
input double Prd =2;
60 ;
input double Sell =40;
input double Sellstop =
60 ;
input double MaximumRisk        = 0.01;    // Maximum Risk in percentage
input double DecreaseFactor     =
30 ;       // Descrease factor
//+------------------------------------------------------------
//+------------------------------------------------------------------+
//    expert start function
//+------------------------------------------------------------------+

ENUM_STO_PRICE StoFieldMigrate(int field)
{
switch(field)
{
case 0: return(STO_LOWHIGH);
case 1: return(STO_CLOSECLOSE);
default: return(STO_LOWHIGH);
}
}
ENUM_APPLIED_PRICE PriceMigrate(int price)
{
switch(price)
{
case 1: return(PRICE_CLOSE);
case 2: return(PRICE_OPEN);
case 3: return(PRICE_HIGH);
case 4: return(PRICE_LOW);
case 5: return(PRICE_MEDIAN);
case 6: return(PRICE_TYPICAL);
case 7: return(PRICE_WEIGHTED);
default: return(PRICE_CLOSE);
}
}

ENUM_TIMEFRAMES TFMigrate(int tf)
{
switch(tf)
{
case 0: return(PERIOD_CURRENT);
case 1: return(PERIOD_M1);

default: return(PERIOD_CURRENT);
}
}

//---
#define EMPTY -1

//+------------------------------------------------------------------+
//| Calculate optimal lot size                                       |
//+------------------------------------------------------------------+
{
double price=0.0;
double margin=0.0;
//--- select lot size
return(0.0);
return(0.0);
if(margin<=0.0)
return(0.0);

double lot=NormalizeDouble(AccountInfoDouble(ACCOUNT_MARGIN_FREE)*MaximumRisk/margin,2);
//--- calculate number of losses orders without a break
if(DecreaseFactor>0)
{
//--- select history for access
HistorySelect(0,TimeCurrent());
//---
int    orders=HistoryDealsTotal();  // total history deals
int    losses=0;                    // number of losses orders without a break

for(int i=orders-1;i>=0;i--)
{
ulong ticket=HistoryDealGetTicket(i);
if(ticket==0)
{
break;
}
//--- check symbol
if(HistoryDealGetString(ticket,DEAL_SYMBOL)!=_Symbol)
continue;
//--- check Expert Magic number
if(HistoryDealGetInteger(ticket,DEAL_MAGIC)!=MagicNumber)
continue;
//--- check profit
double profit=HistoryDealGetDouble(ticket,DEAL_PROFIT);
if(profit>0.0)
break;
if(profit<0.0)
losses++;
}
//---
if(losses>1)
lot=NormalizeDouble(lot-lot*losses/DecreaseFactor,1);
}
//--- normalize and check limits
double stepvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_STEP);
lot=stepvol*NormalizeDouble(lot/stepvol,0);

double minvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MIN);
if(lot<minvol)
lot=minvol;

double maxvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MAX);
if(lot>maxvol)
lot=maxvol;
return(lot);
}

void OnTick()
{
// Check for New Bar
static datetime dtBarCurrent   = WRONG_VALUE;
datetime dtBarPrevious  = dtBarCurrent;
dtBarCurrent   = (datetime) SeriesInfoInteger( _Symbol, _Period, SERIES_LASTBAR_DATE );

bool     boolNewBarFlag = ( dtBarCurrent != dtBarPrevious );

if( boolNewBarFlag ) {
double Bid=SymbolInfoDouble(_Symbol,SYMBOL_BID);

double MyPoint=_Point;
if(_Digits==3 || _Digits==5) MyPoint=_Point*10;
double TheStopLoss=0;
double TheTakeProfit=0;
if( TotalOrdersCount()==0 )
{

{

return;
}

if((iRSIMQL4(NULL,0,Prd,PRICE_CLOSE,00)<Sell)) // Here is your open Sell rule
{
return;
}

}

int posTotal=PositionsTotal();
for(int posIndex=posTotal-1;posIndex>=0;posIndex--)
{
ulong ticket=PositionGetTicket(posIndex);
if(PositionSelectByTicket(ticket) && PositionGetInteger(POSITION_MAGIC)==MagicNumber)
{
{
{
break;
}

if(TrailingStop>0)
{
if(SymbolInfoDouble(_Symbol,SYMBOL_BID)-PositionGetDouble(POSITION_PRICE_OPEN)>MyPoint*TrailingStop)
{
if(PositionGetDouble(POSITION_SL)<SymbolInfoDouble(_Symbol,SYMBOL_BID)-MyPoint*TrailingStop)
{
return;
}
}
}
}

if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL)
{
if((iRSIMQL4(NULL,0,Prd,PRICE_CLOSE,00)>Sellstop)) // here is your close sell rule
{
break;
}
if(TrailingStop>0)
{
{
{
return;
}
}
}
}
}
}
return;
}
}

int TotalOrdersCount()
{
int result=0;
int posTotal=PositionsTotal();
for(int posIndex=posTotal-1;posIndex>=0;posIndex--)
{
ulong ticket=PositionGetTicket(posIndex);
if(PositionSelectByTicket(ticket) && PositionGetInteger(POSITION_MAGIC)==MagicNumber) result++;
}
return (result);
}

int Hour()
{
MqlDateTime tm;
TimeCurrent(tm);
return(tm.hour);
}
int Minute()
{
MqlDateTime tm;
TimeCurrent(tm);
return(tm.min);
}

double CopyBufferMQL4(int handle,int index,int shift)
{
double buf[];
switch(index)
{
case 0: if(CopyBuffer(handle,0,shift,1,buf)>0)
return(buf[0]); break;
case 1: if(CopyBuffer(handle,1,shift,1,buf)>0)
return(buf[0]); break;
case 2: if(CopyBuffer(handle,2,shift,1,buf)>0)
return(buf[0]); break;
case 3: if(CopyBuffer(handle,3,shift,1,buf)>0)
return(buf[0]); break;
case 4: if(CopyBuffer(handle,4,shift,1,buf)>0)
return(buf[0]); break;
default: break;
}
return(EMPTY_VALUE);
}

double iRSIMQL4(string symbol,
int tf,
int period,
int price,
int shift)
{
ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
ENUM_APPLIED_PRICE applied_price=PriceMigrate(price);
int handle=iRSI(symbol,timeframe,period,applied_price);
if(handle<0)
{
return(-1);
}
else
return(CopyBufferMQL4(handle,0,shift));
}

```

First, make a change to your code:

1.strings

```      CTrade trade;
``` input double DecreaseFactor     =