Acquisto vendita con RSI

[texcs]

Salve Ragazzi, ho fatto il seguente programmino:

Codice: Seleziona tutto

int start()
{ 
     
      Alert("Numero Ordini"+CountTrades(MagicID));
      RsiPrec = iRSI(NULL, 0, RsiPeriod, PRICE_CLOSE, 2);//Rsi
      Rsi = iRSI(NULL, 0, RsiPeriod, PRICE_CLOSE, 1);//Rsi
      if(NuovaCandela()==true)
      {
      if(CountTrades(MagicID)==0)
        if((RsiPrec>RsiLevelUp)&&(Rsi<RsiLevelUp))
         {
          OpenBuy(lots, MagicID,3);   // Criterion for opening Buy
         }
         if((RsiPrec>RsiLevelDown)&&(Rsi<RsiLevelDown))
         {     
         OpenSell(lots, MagicID,3);   // Criterion for opening Buy
         }
       }
       if(CountTrades(MagicID)>0)
            TrailingStop(e_TrailingStep,e_TrailingStep);
               
return(0) ;                 
} 

bool NuovaCandela()
{
 
  datetime TempoCandelaAttuale = Time[0]; 
  if (TempoCandelaAttuale != TempoUltimaCandela)
      {
       TempoUltimaCandela = TempoCandelaAttuale;
       return (true); 
      }   
  else
  {
       return (false); 
  }
}
int CountTrades(int MagicNumber) {
   int count = 0;
   for (int trade = OrdersTotal() - 1; trade >= 0; trade--) {
      if (OrderSelect(trade, SELECT_BY_POS, MODE_TRADES))
          continue;
      if (OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber) 
          continue;
      if (OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber)
         if (OrderType() == OP_SELL || OrderType() == OP_BUY) 
            count++;
   }
   return (count);
}

void OpenBuy(double lotti, int MagicNumber,int slipage)
{

   double minstoplevel=MarketInfo(Symbol(),MODE_STOPLEVEL);
   Print("Minimum Stop Level=",minstoplevel," points");
   double price=Ask;
//--- calculated SL and TP prices must be normalized
   double stoploss=NormalizeDouble(Bid-minstoplevel*Point,Digits);
   double takeprofit=NormalizeDouble(Bid+minstoplevel*Point,Digits);
//--- place market order to buy 1 lot
   int ticket=OrderSend(Symbol(),OP_BUY,lotti,price,slipage,stoploss,takeprofit,"My order",MagicNumber,0,clrGreen);
   if(ticket<0)
     {
      Print("OrderSend failed with error #",GetLastError());
     }
   else
      Print("OrderSend placed successfully");
}

void OpenSell(double lotti, int MagicNumber, int slipage)
{

   double minstoplevel=MarketInfo(Symbol(),MODE_STOPLEVEL);
   Print("Minimum Stop Level=",minstoplevel," points");
   double price=Bid;
//--- calculated SL and TP prices must be normalized
   double stoploss=NormalizeDouble(Ask+minstoplevel*Point,Digits);
   double takeprofit=NormalizeDouble(Ask-minstoplevel*Point,Digits);
//--- place market order to buy 1 lot
   int ticket=OrderSend(Symbol(),OP_SELL,lotti,price,slipage,stoploss,takeprofit,"My order",MagicNumber,0,clrGreen);
   if(ticket<0)
     {
      Print("OrderSend failed with error #",GetLastError());
     }
   else
      Print("OrderSend placed successfully");
}
void TrailingStop(double e_trailingstop,double e_trailingstep)
{
   Alert("Ts");
   if (OrderType() == OP_BUY)
    if ((Bid - OrderOpenPrice()) > (e_trailingstop * Point))
      if (OrderStopLoss() < Bid - (e_trailingstop + e_trailingstep - 1) * Point) {
         if (OrderModify(OrderTicket(), OrderOpenPrice(), Ask - e_trailingstop * Point, OrderTakeProfit(), 0, clrGreen))
         return;
      }
  if (OrderType()==OP_SELL)
    if ((OrderOpenPrice() - Ask) > (e_trailingstop * Point))
      if (OrderStopLoss() > Ask + (e_trailingstop + e_trailingstep - 1) * Point || OrderStopLoss()==0) {
         if (OrderModify(OrderTicket(), OrderOpenPrice(), Ask + e_trailingstop * Point, OrderTakeProfit(), 0, clrGreen))
         return;
      }
}

Il programma dovrebbe funzionare nel seguente modo: dichiarate RsiPrec e Rsi che sono rispettivamente i valori dell'rsi alla candela "x-1"(a) e il valore alla candela "x"(b), a ogni nuova candela
"if(NuovaCandela()==true)" e non ci sono ordini "in macchina" (if(CountTrades(MagicID)==0) se il valore(a) è maggiore di RsiLevelUp e valore(b) è minore di RsiLevelUp
(vuol dire che il valore dell'rsi ha "incrociato verso il basso" RsiLevelUP) apre una posizione in Buy(OpenBuy(lots, MagicID,3)), al contrario se il valore(a) è minore di RsiLevelDown e valore(b) è maggiore di RsiLevelDown
(vuol dire che il valore dell'rsi ha "incrociato verso l'alto" RsiLevelDown) apre una posizione in Sell(OpenSell(lots, MagicID,3)); se invece "if(NuovaCandela()==true)" e ci sono ordini "in macchina" (if(CountTrades(MagicID)>0)
ci s il programma chiama la funzione TrailingStop(e_TrailingStep,e_TrailingStep) che dovrebbe gestire il trailingStop all'ordine che c'è in "macchina";
Problemi:
1)Quando faccio Girare il backtest del programma apre e chiude posizioni sulla stessa candela nonostante ci sia la funzione (NuovaCandela() che dovrebbe fare partire i controlli solo se c'è una nuova candela);
2)La funzione CountTrades(MagicID) restituisce sempre 0, cosicchè La funzione TrailingStop "(e_TrailingStep,e_TrailingStep)" non modifica la posizione aperta e l'alert"Alert("Numero Ordini"+CountTrades(MagicID));"
restituisce sempre 0 posizioni aperte ;

[vitto]

Ciao, l'ho gia' pubblicato nell'altro tuo topic e lo riporto anche qui

In pratica non funziona perché il tuo NON è un EA, devi avere un framework di questo tipo

Codice: Seleziona tutto

//+------------------------------------------------------------------+
//|                                                     Texcs RSI EA |
//|                                           https://forexscalp.xyz |
//|                                           https://forexscalp.xyz |
//+------------------------------------------------------------------+

#property copyright "https://forexscalp.xyz"
#property link      "https://forexscalp.xyz"
#property strict

//--- input parameters

input int      nMagic   = 0;     // Magic Number da impostare se usi altri EA in contemporanea
input double   lotSize  = 0.01;  // Il SIZE dell'ordine in lotti
input double   takePip  = 20.0;  // Take profit in PIP
input double   stopPip  = 20.0;  // Stop loss in PIP

double pip = 0.0;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+

int OnInit()
{
   //---

   // Qui ci va il codice che deve essere eseguito
   // 1) Quando lanci l'EA sul Grafico
   // 2) Quando cambi timeframe (dopo il DeInit)
   
   // Il pip del grafico ti serve sicuramente e puoi calcolarlo qui
   
   pip = Point*MathPow(10, Digits%2);
   
   // Chiama l'OnTick cosi' fa "un giro" anche a mercato chiuso
   OnTick();
   
   //---
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+

void OnDeinit(const int reason)
{
   //---
   
   // Qui ci va il codice che deve essere eseguito
   // 1) Quando chiudi il grafico (o cambi template per esempio)
   // 2) Quando cambi timeframe (prima dell'OnInit)

}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+

void OnTick()
{
   //---
   
   // Qui ci va la logica dell'EA che esegue A OGNI TICK del prezzo
   
   if ( true /* QUI CI VA LA CONDIZIONE PER IL BUY */ )
   {
      RefreshRates();
      double stop = NormalizeDouble(Bid - stopPip*pip, Digits);
      double take = NormalizeDouble(Ask + takePip*pip, Digits);
      
      if (OrderSend(NULL, OP_BUY, lotSize, Ask, 0, stop, take, "Texcs MA BUY", nMagic, clrLime) < 0)
      {
         Alert("OPEN BUY ERROR %n", GetLastError());
      }  
                
      return;
   }
   
   if ( true /* QUI CI VA LA CONDIZIONE PER IL SELL */ )
   {
      RefreshRates();
      double stop = NormalizeDouble(Ask + stopPip*pip, Digits);
      double take = NormalizeDouble(Bid - takePip*pip, Digits);         
   
      if (OrderSend(NULL, OP_SELL, lotSize, Bid, 0, stop, take, "Texc MA BUY", nMagic, clrLime) < 0)
      {
         Alert("OPEN SELL ERROR %n", GetLastError());
      }  
           
      return;
   }        

}
  
//+------------------------------------------------------------------+

Adesso guardo bene come deve funzionare il tuo con l'RSI e ne preparo una prima bozza funzionante

Invece per l'altro, fammi sapere se vuoi che ci lavoriamo insieme

[vitto]

Ecco una PRIMA STESURA CHE NON APRE ORDINI, ma la logica è già pronta

Ci sono i due valori rsi0 (RSI candea attuale) e rsi1(RSI candel precedente) in piu' esce dal ciclo se ci sono già ordini in macchina

Basta che mi chiarisci un attimo le condizioni per aprire gli ordini e le mettiamo dentro le due parentesi per il BUY o il SELL (adesso c'è un TRUE solo per non avere errorri di compilazione)

Codice: Seleziona tutto

//+------------------------------------------------------------------+
//|                                                     Texcs RSI EA |
//|                                                By forexscalp.xyz |
//|                                                                  |
//+------------------------------------------------------------------+

#property copyright "https://forexscalp.xyz"
#property link      "https://forexscalp.xyz"
#property strict

//--- input parameters

input int               nMagic      =  0;           // Magic Number da impostare se usi altri EA in contemporanea
input double            lotSize     =  0.01;       // Il SIZE dell'ordine in lotti
input double            takePip     =  20.0;       // Take profit in PIP
input double            stopPip     =  20.0;       // Stop loss in PIP
input ENUM_TIMEFRAMES   timeframe   =  PERIOD_M15; // Qui puoi impostare un timeframe diverso da quello del grafico
                                                   // Cosè puoi cambiare il TF del grafico e l'EA continua a funzionare con il suo 
input int               rsi_period  =  14;         // Periodo dell'RSI
                                                   
datetime lastBAR = 0;
double   pip     = 0.0;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+

int OnInit()
{
   //---

   // Qui ci va il codice che deve essere eseguito
   // 1) Quando lanci l'EA sul Grafico
   // 2) Quando cambi timeframe (dopo il DeInit)
   
   if (lastBAR == 0)
   {
      lastBAR = iTime(NULL, timeframe, 0);
   }
   
   // Il pip del grafico ti serve sicuramente e puoi calcolarlo qui
   
   pip = Point*MathPow(10, Digits%2);
   
   // Chiama l'OnTick cosi' fa "un giro" anche a mercato chiuso
   OnTick();
   
   //---
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+

void OnDeinit(const int reason)
{
   //---
   
   // Qui ci va il codice che deve essere eseguito
   // 1) Quando chiudi il grafico (o cambi template per esempio)
   // 2) Quando cambi timeframe (prima dell'OnInit)

}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+

void OnTick()
{
   //---
   
   // Qui ci va la logica dell'EA che esegue A OGNI TICK del prezzo
   
   if (iTime(NULL, timeframe, 0) > lastBAR)
   {
      for (int i = 0; i < OrdersTotal(); i++)
      {
         if (!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         {
            Alert("SELECT ORDER ERROR # ", GetLastError());
            continue;
         }
         
         if (OrderType() == OP_BUY || OrderType() == OP_SELL)
         {
            return;
         }
      }
   
      double rsi0 = iRSI(NULL, timeframe, rsi_period, PRICE_CLOSE, 0);
      double rsi1 = iRSI(NULL, timeframe, rsi_period, PRICE_CLOSE, 1);     
      
      if ( true/* QUI CI VA LA CONDIZIONE PER IL BUY */ )
      {
         RefreshRates();
         double stop = NormalizeDouble(Bid - stopPip*pip, Digits);
         double take = NormalizeDouble(Ask + takePip*pip, Digits);
         
         if (OrderSend(NULL, OP_BUY, lotSize, Ask, 0, stop, take, "Texcs MA BUY", nMagic, clrLime) < 0)
         {
            Alert("OPEN BUY ERROR %n", GetLastError());
         }  
                   
         return;
      }
      
      if ( true /* QUI CI VA LA CONDIZIONE PER IL SELL */ )
      {
         RefreshRates();
         double stop = NormalizeDouble(Ask + stopPip*pip, Digits);
         double take = NormalizeDouble(Bid - takePip*pip, Digits);         
      
         if (OrderSend(NULL, OP_SELL, lotSize, Bid, 0, stop, take, "Texc MA BUY", nMagic, clrLime) < 0)
         {
            Alert("OPEN SELL ERROR %n", GetLastError());
         }  
              
         return;
      }        
   }   

}
  
//+------------------------------------------------------------------+

[texcs]

Ciao, grazie della risposta , mi spieghi come mai hai messo già il "true" in
" f ( true /* QUI CI VA LA CONDIZIONE PER IL SELL */ ) "

[vitto]

Ciao, grazie della risposta , mi spieghi come mai hai messo già il "true" in
" f ( true /* QUI CI VA LA CONDIZIONE PER IL SELL */ ) "

Ciao e figurati!

Adesso il framework è pronto, mancano solo le condizioni per il buy e il sell, se vuoi puoi metterle tu, se no me le dici e le metto io, perché cosi' le isoliamo dalla spiegazione iniziale e ci concentriamo solo su quelle

Il true serve solo come placeholder per evitare che dia errore in fase di compilazione, se no potrebbe mascherarne altri

Invece con il true siamo sicuri che è tutto corretto e basta mettere la logica che vuoi per i ssegnali di input... e il lavoro è finito!

[texcs]

1)Ho sistemato il tuo codice con queste condizioni:
Per buy

Codice: Seleziona tutto

if ((RsiPrec>RsiLevelUp)&&(Rsi<RsiLevelUp)) 

Per sell

Codice: Seleziona tutto

if ( (RsiPrec>RsiLevelDown)&&(Rsi<RsiLevelDown) )

e funziona

2)Volevo strutturarlo in fuzioni separate e inserire la funzione TrailingStop(), ho provato nel seguente modo però non funziona sia con che senza TrailingStop();

Codice: Seleziona tutto

//+------------------------------------------------------------------+
//|                                                     Texcs RSI EA |
//|                                                By forexscalp.xyz |
//|                                                                  |
//+------------------------------------------------------------------+

#property copyright "https://forexscalp.xyz"
#property link      "https://forexscalp.xyz"
#property strict

//--- input parameters
extern   double   e_TrailingStop             = 35;
extern   double   e_TrailingStep             = 5;
input int               nMagic      =  0;           // Magic Number da impostare se usi altri EA in contemporanea
extern int RsiLevelUp               =  60;    //
extern int RsiLevelDown             =  40;
input double            lotSize     =  0.01;       // Il SIZE dell'ordine in lotti
input double            takePip     =  20.0;       // Take profit in PIP
input double            stopPip     =  20.0;       // Stop loss in PIP
input ENUM_TIMEFRAMES   timeframe   =  PERIOD_M15; // Qui puoi impostare un timeframe diverso da quello del grafico
                                                   // Cosè puoi cambiare il TF del grafico e l'EA continua a funzionare con il suo 
input int               rsi_period  =  14;         // Periodo dell'RSI
                                                 
datetime lastBAR = 0;
double   pip     = 0.0;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+

int OnInit()
{
   //---

   // Qui ci va il codice che deve essere eseguito
   // 1) Quando lanci l'EA sul Grafico
   // 2) Quando cambi timeframe (dopo il DeInit)
   
   if (lastBAR == 0)
   {
      lastBAR = iTime(NULL, timeframe, 0);
   }
   
   // Il pip del grafico ti serve sicuramente e puoi calcolarlo qui
   
   pip = Point*MathPow(10, Digits%2);
   
   // Chiama l'OnTick cosi' fa "un giro" anche a mercato chiuso
   OnTick();
   
   //---
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+

void OnDeinit(const int reason)
{
   //---
   
   // Qui ci va il codice che deve essere eseguito
   // 1) Quando chiudi il grafico (o cambi template per esempio)
   // 2) Quando cambi timeframe (prima dell'OnInit)

}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+

void OnTick()
{
   //---
   
   // Qui ci va la logica dell'EA che esegue A OGNI TICK del prezzo
   
   if (iTime(NULL, timeframe, 0) > lastBAR)
   {
     if(OrdersTotal()==0) 
         for (int i = 0; i < OrdersTotal(); i++)
         {
            if (!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
            {
               Alert("SELECT ORDER ERROR # ", GetLastError());
               continue;
            }
            
            if (OrderType() == OP_BUY || OrderType() == OP_SELL)
            {
               return;
            }
         }
      
         double Rsi = iRSI(NULL, timeframe, rsi_period, PRICE_CLOSE, 0);
         double RsiPrec = iRSI(NULL, timeframe, rsi_period, PRICE_CLOSE, 1);     
         
         if ((RsiPrec>RsiLevelUp)&&(Rsi<RsiLevelUp))
            OpenBuy(lotSize,nMagic,0);
         
         if((RsiPrec>RsiLevelDown)&&(Rsi<RsiLevelDown))
            OpenSell(lotSize,nMagic,0);     
   }   
   else
   TrailingStop(e_TrailingStep,e_TrailingStep);
      
  
}
  
void TrailingStop(double e_trailingstop,double e_trailingstep){
   Alert("Ts");
   if (OrderType() == OP_BUY)
    if ((Bid - OrderOpenPrice()) > (e_trailingstop * Point))
      if (OrderStopLoss() < Bid - (e_trailingstop + e_trailingstep - 1) * Point) {
         if (OrderModify(OrderTicket(), OrderOpenPrice(), Ask - e_trailingstop * Point, OrderTakeProfit(), 0, clrGreen))
         return;
      }
  if (OrderType()==OP_SELL)
    if ((OrderOpenPrice() - Ask) > (e_trailingstop * Point))
      if (OrderStopLoss() > Ask + (e_trailingstop + e_trailingstep - 1) * Point || OrderStopLoss()==0) {
         if (OrderModify(OrderTicket(), OrderOpenPrice(), Ask + e_trailingstop * Point, OrderTakeProfit(), 0, clrGreen))
         return;
      }
}



void OpenBuy(double lotti, int MagicNumber,int slipage)
{

   double minstoplevel=MarketInfo(Symbol(),MODE_STOPLEVEL);
   Print("Minimum Stop Level=",minstoplevel," points");
   double price=Ask;
//--- calculated SL and TP price0s must be normalized
   double stoploss=NormalizeDouble(Bid-minstoplevel*Point,Digits);
   double takeprofit=NormalizeDouble(Bid+minstoplevel*Point,Digits);
//--- place market order to buy 1 lot
   RefreshRates();
   int ticket=OrderSend(Symbol(),OP_BUY,lotti,price,slipage,stoploss,takeprofit,"My order",MagicNumber,0,clrGreen);
   if(ticket<0)
     {
      Print("OrderSend failed with error #",GetLastError());
     }
   else
      Print("OrderSend placed successfully");
}


void OpenSell(double lotti, int MagicNumber, int slipage)
{

   double minstoplevel=MarketInfo(Symbol(),MODE_STOPLEVEL);
   Print("Minimum Stop Level=",minstoplevel," points");
   double price=Bid;
//--- calculated SL and TP prices must be normalized
   double stoploss=NormalizeDouble(Ask+minstoplevel*Point,Digits);
   double takeprofit=NormalizeDouble(Ask-minstoplevel*Point,Digits);
//--- place market order to buy 1 lot
   RefreshRates();
   int ticket=OrderSend(Symbol(),OP_SELL,lotti,price,slipage,stoploss,takeprofit,"My order",MagicNumber,0,clrGreen);
   if(ticket<0)
     {
      Print("OrderSend failed with error #",GetLastError());
     }
   else
      Print("OrderSend placed successfully");
}

Però non va, Potresti darci un occhiata??

[vitto]

1)Ho sistemato il tuo codice con queste condizioni:

...omissis...

Grande! Complimenti, integrazione perfetta

Per il trailing, adesso ti inserisco quello che uso io, perché è già collaudato e solido con il framework di base che abbiamo usato

Adesso ho ancora 20 minuti liberi (pausa pranzo) se non riesco a finirlo in tempo, poi sono libero stasera e sicuramente lo finiamo

[vitto]

1)Ho sistemato il tuo codice con queste condizioni:
Per buy

Codice: Seleziona tutto

if ((RsiPrec>RsiLevelUp)&&(Rsi<RsiLevelUp)) 

Per sell

Codice: Seleziona tutto

if ( (RsiPrec>RsiLevelDown)&&(Rsi<RsiLevelDown) )

e funziona

Dimenticavo, mi alleghi il tuo che hai sistemato con le condizioni negli if, così metto il trading in quello e rimaniamo allineati

[texcs]

1)Ho sistemato il tuo codice con queste condizioni:
Per buy

Codice: Seleziona tutto

if ((RsiPrec>RsiLevelUp)&&(Rsi<RsiLevelUp)) 

Per sell

Codice: Seleziona tutto

if ( (RsiPrec>RsiLevelDown)&&(Rsi<RsiLevelDown) )

e funziona

2)Volevo strutturarlo in fuzioni separate e inserire la funzione TrailingStop(), ho provato nel seguente modo però non funziona sia con che senza TrailingStop();

Codice: Seleziona tutto

//+------------------------------------------------------------------+
//|                                                     Texcs RSI EA |
//|                                                By forexscalp.xyz |
//|                                                                  |
//+------------------------------------------------------------------+

#property copyright "https://forexscalp.xyz"
#property link      "https://forexscalp.xyz"
#property strict

//--- input parameters
extern   double   e_TrailingStop             = 35;
extern   double   e_TrailingStep             = 5;
input int               nMagic      =  0;           // Magic Number da impostare se usi altri EA in contemporanea
extern int RsiLevelUp               =  60;    //
extern int RsiLevelDown             =  40;
input double            lotSize     =  0.01;       // Il SIZE dell'ordine in lotti
input double            takePip     =  20.0;       // Take profit in PIP
input double            stopPip     =  20.0;       // Stop loss in PIP
input ENUM_TIMEFRAMES   timeframe   =  PERIOD_M15; // Qui puoi impostare un timeframe diverso da quello del grafico
                                                   // Cosè puoi cambiare il TF del grafico e l'EA continua a funzionare con il suo 
input int               rsi_period  =  14;         // Periodo dell'RSI
                                                 
datetime lastBAR = 0;
double   pip     = 0.0;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+

int OnInit()
{
   //---

   // Qui ci va il codice che deve essere eseguito
   // 1) Quando lanci l'EA sul Grafico
   // 2) Quando cambi timeframe (dopo il DeInit)
   
   if (lastBAR == 0)
   {
      lastBAR = iTime(NULL, timeframe, 0);
   }
   
   // Il pip del grafico ti serve sicuramente e puoi calcolarlo qui
   
   pip = Point*MathPow(10, Digits%2);
   
   // Chiama l'OnTick cosi' fa "un giro" anche a mercato chiuso
   OnTick();
   
   //---
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+

void OnDeinit(const int reason)
{
   //---
   
   // Qui ci va il codice che deve essere eseguito
   // 1) Quando chiudi il grafico (o cambi template per esempio)
   // 2) Quando cambi timeframe (prima dell'OnInit)

}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+

void OnTick()
{
   //---
   
   // Qui ci va la logica dell'EA che esegue A OGNI TICK del prezzo
   
   if (iTime(NULL, timeframe, 0) > lastBAR)
   {
     if(OrdersTotal()==0) 
         for (int i = 0; i < OrdersTotal(); i++)
         {
            if (!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
            {
               Alert("SELECT ORDER ERROR # ", GetLastError());
               continue;
            }
            
            if (OrderType() == OP_BUY || OrderType() == OP_SELL)
            {
               return;
            }
         }
      
         double Rsi = iRSI(NULL, timeframe, rsi_period, PRICE_CLOSE, 0);
         double RsiPrec = iRSI(NULL, timeframe, rsi_period, PRICE_CLOSE, 1);     
         
         if ((RsiPrec>RsiLevelUp)&&(Rsi<RsiLevelUp))
            OpenBuy(lotSize,nMagic,0);
         
         if((RsiPrec>RsiLevelDown)&&(Rsi<RsiLevelDown))
            OpenSell(lotSize,nMagic,0);     
   }   
   else
   TrailingStop(e_TrailingStep,e_TrailingStep);
      
  
}
  
void TrailingStop(double e_trailingstop,double e_trailingstep){
   Alert("Ts");
   if (OrderType() == OP_BUY)
    if ((Bid - OrderOpenPrice()) > (e_trailingstop * Point))
      if (OrderStopLoss() < Bid - (e_trailingstop + e_trailingstep - 1) * Point) {
         if (OrderModify(OrderTicket(), OrderOpenPrice(), Ask - e_trailingstop * Point, OrderTakeProfit(), 0, clrGreen))
         return;
      }
  if (OrderType()==OP_SELL)
    if ((OrderOpenPrice() - Ask) > (e_trailingstop * Point))
      if (OrderStopLoss() > Ask + (e_trailingstop + e_trailingstep - 1) * Point || OrderStopLoss()==0) {
         if (OrderModify(OrderTicket(), OrderOpenPrice(), Ask + e_trailingstop * Point, OrderTakeProfit(), 0, clrGreen))
         return;
      }
}



void OpenBuy(double lotti, int MagicNumber,int slipage)
{

   double minstoplevel=MarketInfo(Symbol(),MODE_STOPLEVEL);
   Print("Minimum Stop Level=",minstoplevel," points");
   double price=Ask;
//--- calculated SL and TP price0s must be normalized
   double stoploss=NormalizeDouble(Bid-minstoplevel*Point,Digits);
   double takeprofit=NormalizeDouble(Bid+minstoplevel*Point,Digits);
//--- place market order to buy 1 lot
   RefreshRates();
   int ticket=OrderSend(Symbol(),OP_BUY,lotti,price,slipage,stoploss,takeprofit,"My order",MagicNumber,0,clrGreen);
   if(ticket<0)
     {
      Print("OrderSend failed with error #",GetLastError());
     }
   else
      Print("OrderSend placed successfully");
}


void OpenSell(double lotti, int MagicNumber, int slipage)
{

   double minstoplevel=MarketInfo(Symbol(),MODE_STOPLEVEL);
   Print("Minimum Stop Level=",minstoplevel," points");
   double price=Bid;
//--- calculated SL and TP prices must be normalized
   double stoploss=NormalizeDouble(Ask+minstoplevel*Point,Digits);
   double takeprofit=NormalizeDouble(Ask-minstoplevel*Point,Digits);
//--- place market order to buy 1 lot
   RefreshRates();
   int ticket=OrderSend(Symbol(),OP_SELL,lotti,price,slipage,stoploss,takeprofit,"My order",MagicNumber,0,clrGreen);
   if(ticket<0)
     {
      Print("OrderSend failed with error #",GetLastError());
     }
   else
      Print("OrderSend placed successfully");
}

Però non va, Potresti darci un occhiata??

è questo

[vitto]

Eccomi a casa e guardo subito il trading, poi continuo lo studio dell'mql4 e degli EA... se qualcuno ha un'idea da realizzare, basta aprire un nuovo topic con il NOME DELL'EA nel titolo... e si parte!