Skip to content
TheChatArchiveThe Chat Archive
gpt-4-1106-preview· OpenAIAi2 WildChat-4.8M (AI2)

//+------------------------------------------------------------------+ // SpudFrye…

  1. User

    //+------------------------------------------------------------------+ //| SpudFrye Method I EA v001.mq4 | //| Copyright © 2007, NonDisclosure007. | //| Props to the following: | //| Rob Rice (blueruby) for his indicator SpudFyre Stochs.mq4 | //+------------------------------------------------------------------+ #property copyright "Copyright © 2007, NonDisclosure007." #property link "None" #include <stdlib.mqh> #include <stderror.mqh> extern double Lots = 1; // standard lot size. //+---------------------------------------------------+ //|Profit controls | //+---------------------------------------------------+ extern double StopLoss = 100; // Maximum pips willing to lose per position. extern bool UseTrailingStop = true; extern int TrailingStopType = 2; // Type 1 moves stop immediately, Type 2 waits til value of TS is reached extern double TrailingStop = 25; // Change to whatever number of pips you wish to trail your position with. extern bool UseTakeProfit = false; extern int TakeProfit = 999; // Maximum profit level achieved. extern int Slippage = 3; // Possible fix for not getting filled or closed extern string label = "== choose 15, 30, 60, 240 (4 hours) for timeframe exit"; extern int exittimeframe = 30; // extern int SignalCandle=1; double myStopLoss;
    double lotMM; int MagicNumber; string setup = ""; int totalTries = 5; int retryDelay = 1000; datetime timeprev=0; bool Debug=false;

    double lowlimit=20; double highlimit=80;

    int init() { MagicNumber = 5000 + Symbol2Val(Symbol())*100 + TimeFrame_Const2Val(Period()); setup="Stoch 5 EA " + Symbol() + "_" + TimeFrame_Val2String(TimeFrame_Const2Val(Period()));

    return(0); }

    int deinit() { return(0); }

    int start()

    { BeginHandleStopLoss(); if (newbar()==Period()) { HandleOpenPositions(); if (CheckOpenPositions() > 0) { return(0); } lotMM = Lots; if(BuySignal())
    { OpenBuyOrder(); return(0); } else if(SellSignal()) { OpenSellOrder(); return(0); } } return(0); }

    int newbar() { double g; int m,s,k; m=Time[0]+Period()*60-TimeCurrent(); g=m/60.0; s=m%60; m=(m-m%60)/60; return(m); } int BeginHandleStopLoss() { int cnt;

    for(cnt=OrdersTotal()-1;cnt>=0;cnt--) { OrderSelect (cnt, SELECT_BY_POS, MODE_TRADES); if ( OrderSymbol() != Symbol()) continue; if ( OrderMagicNumber() != MagicNumber) continue;

      if(OrderType() == OP_BUY)
      {
            if (UseTrailingStop)
            {
               HandleTrailingStop(OP_BUY,OrderTicket(),OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit());
            }
      }
    
      if(OrderType() == OP_SELL)
      {
             if(UseTrailingStop)  
             {                
               HandleTrailingStop(OP_SELL,OrderTicket(),OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit());
             }
       }
    

    }return(0); }

    bool stochOpen(string signal) { bool stochbool=false; double main_15 = iStochastic(NULL,PERIOD_M15,14,3,3,MODE_SMA,0,MODE_MAIN,1); double main_15last = iStochastic(NULL,PERIOD_M15,14,3,3,MODE_SMA,0,MODE_MAIN,2); double main_30 = iStochastic(NULL,PERIOD_M30,14,3,3,MODE_SMA,0,MODE_MAIN,1); double main_30last = iStochastic(NULL,PERIOD_M30,14,3,3,MODE_SMA,0,MODE_MAIN,2); double main_1H = iStochastic(NULL,PERIOD_H1,14,3,3,MODE_SMA,0,MODE_MAIN,1); double main_1Hlast = iStochastic(NULL,PERIOD_H1,14,3,3,MODE_SMA,0,MODE_MAIN,2); double main_4H = iStochastic(NULL,PERIOD_H4,14,3,3,MODE_SMA,0,MODE_MAIN,1); double main_4Hlast = iStochastic(NULL,PERIOD_H4,14,3,3,MODE_SMA,0,MODE_MAIN,2); //---------------------- double main_152 = iStochastic(NULL,PERIOD_M15,14,3,3,MODE_SMA,0,MODE_MAIN,1); double main_152last = iStochastic(NULL,PERIOD_M15,14,3,3,MODE_SMA,0,MODE_MAIN,2);
    double main_302 = iStochastic(NULL,PERIOD_M30,14,3,3,MODE_SMA,0,MODE_MAIN,1); double main_302last = iStochastic(NULL,PERIOD_M30,14,3,3,MODE_SMA,0,MODE_MAIN,2); double main_1H2 = iStochastic(NULL,PERIOD_H1,14,3,3,MODE_SMA,0,MODE_MAIN,1); double main_1H2last = iStochastic(NULL,PERIOD_H1,14,3,3,MODE_SMA,0,MODE_MAIN,2); double main_4H2 = iStochastic(NULL,PERIOD_H4,14,3,3,MODE_SMA,0,MODE_MAIN,1); double main_4H2last = iStochastic(NULL,PERIOD_H4,14,3,3,MODE_SMA,0,MODE_MAIN,2);

    if (signal=="Short" && (main_15 < main_15last) && (main_15last > highlimit) && (main_15 < highlimit) && (main_30 < main_15last) && (main_30last > highlimit) && (main_30 < highlimit) && (main_1H < main_15last) && (main_1Hlast > highlimit) && (main_1H < highlimit) && (main_4H < main_15last) && (main_4Hlast > highlimit) && (main_4H < highlimit) && (main_152 < main_15last) && (main_152last > highlimit) && (main_152 < highlimit) && (main_302 < main_15last) && (main_302last > highlimit) && (main_302 < highlimit) && (main_1H2 < main_15last) && (main_1H2last > highlimit) && (main_1H2 < highlimit) && (main_4H2 < main_15last) && (main_4H2last > highlimit) && (main_4H2 < highlimit)) stochbool=true; if (signal=="Long" && (main_15 > main_15last) && (main_15last < lowlimit) && (main_15 > lowlimit) && (main_30 > main_15last) && (main_30last < lowlimit) && (main_30 > lowlimit) && (main_1H > main_15last) && (main_1Hlast < lowlimit) && (main_1H > lowlimit) && (main_4H > main_15last) && (main_4Hlast < lowlimit) && (main_4H > lowlimit) && (main_152 > main_15last) && (main_152last < lowlimit) && (main_152 > lowlimit) && (main_302 > main_15last) && (main_302last < lowlimit) && (main_302 > lowlimit) && (main_1H2 > main_15last) && (main_1H2last < lowlimit) && (main_1H2 > lowlimit) && (main_4H2 > main_15last) && (main_4H2last < lowlimit) && (main_4H2 > lowlimit)) stochbool=true; return(stochbool); }

    bool stochClose(string signal) { bool stochbool = false; // double main_1H = iStochastic(NULL,exittimeframe,14,3,3,MODE_SMA,0,MODE_MAIN,1); // double main_1H2 = iStochastic(NULL,exittimeframe,14,3,3,MODE_SMA,0,MODE_MAIN,2);

    // if (signal=="LongExit" && main_1H > highlimit) stochbool=true; // if (signal=="ShortExit" && main_1H < lowlimit) stochbool=true; // return(stochbool); } bool BuySignal() { if (stochOpen("Long")==true) return(true); else return(false);
    }

    bool SellSignal() { if (stochOpen("Short")==true) return(true); else return(false);
    }

    bool BuyExitSignal() { if (stochClose("LongExit")==true) return(true); else return(false); } bool SellExitSignal() { if (stochClose("ShortExit")==true) return(true); else return(false); }

    //+------------------------------------------------------------------+ //| OpenBuyOrder | //| If Stop Loss or TakeProfit are used the values are calculated | //| for each trade | //+------------------------------------------------------------------+ void OpenBuyOrder() { int ticket; int cnt, err, digits; double myStopLoss = 0, myTakeProfit = 0, myPrice = 0;

    myPrice = MarketInfo(Symbol(), MODE_ASK); myStopLoss = 0; if ( StopLoss > 0 ) myStopLoss = myPrice - StopLoss * Point ; if (myStopLoss != 0) ValidStopLoss(OP_BUY, myStopLoss); myTakeProfit = 0; if (UseTakeProfit && TakeProfit>0) myTakeProfit = myPrice + TakeProfit * Point; // Normalize all price / stoploss / takeprofit to the proper # of digits. digits = MarketInfo(Symbol(), MODE_DIGITS); if (digits > 0) { myPrice = NormalizeDouble(myPrice, digits); myStopLoss = NormalizeDouble(myStopLoss, digits); myTakeProfit = NormalizeDouble(myTakeProfit, digits); } OrderSend(Symbol(),OP_BUY,Lots,myPrice,Slippage,myStopLoss,myTakeProfit,setup,MagicNumber,0,LimeGreen); //myStopLoss,myTakeProfit if (ticket > 0) { if (OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES)) { if (Debug) Print("BUY order opened : ", OrderOpenPrice()); } } else { err = GetLastError(); Print("Error opening BUY order : (" + err + ") " + ErrorDescription(err)); } } //+------------------------------------------------------------------+ //| OpenSellOrder | //| If Stop Loss or TakeProfit are used the values are calculated | //| for each trade | //+------------------------------------------------------------------+ void OpenSellOrder() { int ticket; int cnt, err, digits; double myStopLoss = 0, myTakeProfit = 0, myPrice = 0;

    myPrice = MarketInfo(Symbol(), MODE_BID); myStopLoss = 0; if ( StopLoss > 0 ) myStopLoss = myPrice + StopLoss * Point ; if (myStopLoss != 0) ValidStopLoss(OP_SELL, myStopLoss); myTakeProfit = 0; if (UseTakeProfit && TakeProfit > 0) myTakeProfit = myPrice - TakeProfit * Point; // Normalize all price / stoploss / takeprofit to the proper # of digits. digits = MarketInfo(Symbol(), MODE_DIGITS); if (digits > 0) { myPrice = NormalizeDouble(myPrice, digits); myStopLoss = NormalizeDouble(myStopLoss, digits); myTakeProfit = NormalizeDouble(myTakeProfit, digits); } ticket=OrderSend(Symbol(),OP_SELL,Lots,myPrice,Slippage,myStopLoss,myTakeProfit,setup,MagicNumber,0,Red); //myStopLoss,myTakeProfit if (ticket > 0) { if (OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES)) { if (Debug) Print("SELL order opened : ", OrderOpenPrice()); } } else { err = GetLastError(); Print("Error opening SELL order : (" + err + ") " + ErrorDescription(err)); } return(0); } //+------------------------------------------------------------------+ //| Check Open Position Controls | //+------------------------------------------------------------------+ int CheckOpenPositions() { int cnt, total, NumPositions; int NumBuyTrades, NumSellTrades; // Number of buy and sell trades in this symbol

    NumBuyTrades = 0; NumSellTrades = 0; total=OrdersTotal(); for(cnt=OrdersTotal()-1;cnt>=0;cnt--) { OrderSelect (cnt, SELECT_BY_POS, MODE_TRADES); if ( OrderSymbol() != Symbol()) continue; if ( OrderMagicNumber() != MagicNumber) continue; if(OrderType() == OP_BUY ) NumBuyTrades++; if(OrderType() == OP_SELL ) NumSellTrades++; } NumPositions = NumBuyTrades + NumSellTrades; return (NumPositions); } //+------------------------------------------------------------------+ //| Modify Open Position Controls | //| Try to modify position 3 times | //+------------------------------------------------------------------+ bool ModifyOrder(int nOrderType, int ord_ticket,double op, double price,double tp, color mColor = CLR_NONE) { int cnt, err; double myStop;

    myStop = ValidStopLoss (nOrderType, price);
    cnt=0;
    while (cnt < totalTries)
    {
       if (OrderModify(ord_ticket,op,myStop,tp,0,mColor))
       {
         return(true);
       }
       else
       {
          err=GetLastError();
          if (err > 1) Print(cnt," Error modifying order : (", ord_ticket , ") " + ErrorDescription(err), " err ",err);
          if (err>0) cnt++;
          Sleep(retryDelay);
       }
    }
    return(false);
    

    } // Adjust stop loss so that it is legal. double ValidStopLoss(int cmd, double sl) {

    if (sl == 0) return(0.0);

    double mySL, myPrice; double dblMinStopDistance = MarketInfo(Symbol(),MODE_STOPLEVEL)*MarketInfo(Symbol(), MODE_POINT);

    mySL = sl; // Check if SlopLoss needs to be modified switch(cmd) { case OP_BUY: myPrice = MarketInfo(Symbol(), MODE_BID); if (myPrice - sl < dblMinStopDistance) mySL = myPrice - dblMinStopDistance; // we are long break; case OP_SELL: myPrice = MarketInfo(Symbol(), MODE_ASK); if (sl - myPrice < dblMinStopDistance) mySL = myPrice + dblMinStopDistance; // we are long } return(NormalizeDouble(mySL,MarketInfo(Symbol(), MODE_DIGITS))); } //+------------------------------------------------------------------+ //| HandleTrailingStop | //| Type 1 moves the stoploss without delay. | //| Type 2 waits for price to move the amount of the trailStop | //| before moving stop loss then moves like type 1 | //| Type 3 uses up to 3 levels for trailing stop | //| Level 1 Move stop to 1st level | //| Level 2 Move stop to 2nd level | //| Level 3 Trail like type 1 by fixed amount other than 1 | //| Possible future types | //| Type 4 uses 2 for 1, every 2 pip move moves stop 1 pip | //| Type 5 uses 3 for 1, every 3 pip move moves stop 1 pip | //+------------------------------------------------------------------+ int HandleTrailingStop(int type, int ticket, double op, double os, double tp) { double pt, TS=0, myAsk, myBid; double bos,bop,opa,osa;

    switch(type)
    {
       case OP_BUY:
       {
    	 myBid = MarketInfo(Symbol(),MODE_BID);
       switch(TrailingStopType)
       {
        case 1: pt = Point*StopLoss;
                if(myBid-os > pt)
                 ModifyOrder(type, ticket,op,myBid-pt,tp, Aqua);
                break;
        case 2: pt = Point*TrailingStop;
                if(myBid-op > pt && os < myBid - pt)
                 ModifyOrder(type, ticket,op,myBid-pt,tp, Aqua);
                break;
       }
       return(0);
       break;
       }
    case  OP_SELL:
    {
    	myAsk = MarketInfo(Symbol(),MODE_ASK);
       switch(TrailingStopType)
       {
        case 1: pt = Point*StopLoss;
                if(os - myAsk > pt)
                 ModifyOrder(type, ticket,op,myAsk+pt,tp, Aqua);
                break;
        case 2: pt = Point*TrailingStop;
                if(op - myAsk > pt && os > myAsk+pt)
                 ModifyOrder(type, ticket,op,myAsk+pt,tp, Aqua);
                break;
       }
    }
    return(0);
    }
    

    }

    //+------------------------------------------------------------------+ //| Handle Open Positions | //| Check if any open positions need to be closed or modified | //+------------------------------------------------------------------+ int HandleOpenPositions() { int cnt;

    for(cnt=OrdersTotal()-1;cnt>=0;cnt--) { OrderSelect (cnt, SELECT_BY_POS, MODE_TRADES); if ( OrderSymbol() != Symbol()) continue; if ( OrderMagicNumber() != MagicNumber) continue;

      if(OrderType() == OP_BUY)
      {
            
         if ( BuyExitSignal())
          {
               OrderClose(OrderTicket(),OrderLots(),Bid, Slippage, Violet);
          }
          else
          {
            if (UseTrailingStop)
            {
               HandleTrailingStop(OP_BUY,OrderTicket(),OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit());
            }
          }
      }
    
      if(OrderType() == OP_SELL)
      {
          if (SellExitSignal())
          {
             OrderClose(OrderTicket(),OrderLots(),Ask, Slippage, Violet);
          }
          else
          {
             if(UseTrailingStop)  
             {                
               HandleTrailingStop(OP_SELL,OrderTicket(),OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit());
             }
          }
       }
    

    } }

    //+------------------------------------------------------------------+ //| Time frame interval appropriation function | //+------------------------------------------------------------------+ int TimeFrame_Const2Val(int Constant ) { switch(Constant) { case 1:
    return(1); case 5:
    return(2); case 15: return(3); case 30: return(4); case 60: return(5); case 240: return(6); case 1440: return(7); case 10080: return(8); case 43200: return(9); } } //+------------------------------------------------------------------+ //| Time frame string appropriation function | //+------------------------------------------------------------------+ string TimeFrame_Val2String(int Value ) { switch(Value) { case 1:
    return("PERIOD_M1"); case 2:
    return("PERIOD_M5"); case 3: return("PERIOD_M15"); case 4: return("PERIOD_M30"); case 5: return("PERIOD_H1"); case 6: return("PERIOD_H4"); case 7: return("PERIOD_D1"); case 8: return("PERIOD_W1"); case 9: return("PERIOD_MN1"); default: return("undefined " + Value); } } int Symbol2Val(string symbol) { string mySymbol = StringSubstr(symbol,0,6); if(mySymbol=="AUDCAD") return(1); if(mySymbol=="AUDJPY") return(2); if(mySymbol=="AUDNZD") return(3); if(mySymbol=="AUDUSD") return(4); if(mySymbol=="CHFJPY") return(5); if(mySymbol=="EURAUD") return(6); if(mySymbol=="EURCAD") return(7); if(mySymbol=="EURCHF") return(8); if(mySymbol=="EURGBP") return(9); if(mySymbol=="EURJPY") return(10); if(mySymbol=="EURUSD") return(11); if(mySymbol=="GBPCHF") return(12); if(mySymbol=="GBPJPY") return(13); if(mySymbol=="GBPUSD") return(14); if(mySymbol=="NZDUSD") return(15); if(mySymbol=="USDCAD") return(16); if(mySymbol=="USDCHF") return(17); if(mySymbol=="USDJPY") return(18); return(19); }

    questo EA apre dei trade in base allo stocastico su più timeframes. ma ci sono degli errori poichè non apre nulla. trova gli errori e correggili

  2. Assistant

    Ho trovato alcuni potenziali problemi e aree di miglioramento nel codice. Di seguito, evidenzio ed effettuo le correzioni:

    1. Validazione del ticket in OpenBuyOrder e OpenSellOrder. La variabile ticket dovrebbe essere utilizzata per verificare se l'ordine è stato aperto con successo, ma non è impostata correttamente dato che non è assegnata al risultato della chiamata OrderSend.

      Correzione: Sostituisci int ticket; con int ticket = OrderSend(...); nelle funzioni OpenBuyOrder e OpenSellOrder.

    2. Funzione stochClose non è implementata. La funzione stochClose è incompleta e problematica, può essere chiamata ma sempre ritorna false, e quindi non scatena mai una chiusura dei trade.

      Correzione: Implementa la funzione stochClose o rimuovi i riferimenti a essa se non è ancora previsto il suo utilizzo.

    3. Valori stocastici ripetuti nelle funzioni stochOpen e stochClose. Nella funzione stochOpen, vengono effettuate chiamate ripetute alle stesse funzioni di indicatori con gli stessi parametri.

      Correzione: Elimina le chiamate ripetute e riutilizza i valori dove appropriato. Ad esempio:

      double main_15 = iStochastic(NULL,PERIOD_M15,14,3,3,MODE_SMA,0,MODE_MAIN,1); // Usato correttamente
      // Rimuovi questa chiamata duplicata
      // double main_152 = iStochastic(NULL,PERIOD_M15,14,3,3,MODE_SMA,0,MODE_MAIN,1);
      
    4. Controllo di newbar(). La funzione newbar() sembra avere un'implementazione errata e potrebbe non restituire il valore corretto per determinare se c'è una nuova barra.

      Correzione: Correggi la logica per calcolare correttamente se è presente una nuova barra. Ad esempio, si può verificare il tempo dell'ultima barra memorizzandolo e controllando se quello corrente è diverso.

    5. Dichiarazione e inizializzazione variabili. Alcune variabili come double myStopLoss; sono dichiarate ma mai utilizzate o inizializzate correttamente, ciò potrebbe causare comportamenti imprevisti. Assicurati di inizializzare tutte le variabili e utilizzare quelle dichiarate.

    6. Verifica di MagicNumber unico. La composizione di MagicNumber potrebbe non essere univoca per ogni combinazione di simbolo e timeframe, specialmente se Symbol2Val restituisce valori che non sono unici per corrispondenti coppie di valute.

      Correzione: Assicurati che Symbol2Val e la combinazione con TimeFrame_Const2Val creino un MagicNumber univoco per ogni coppia di azioni EA.

    7. Colori non definiti. Se stai usando una versione MT4 che non ha i colori LimeGreen e Red predefiniti, assicurati di definirli prima di usarli o sostituiscili con colori riconosciuti.

    Rivedi e testa accuratamente le modifiche dopo ogni correzione per assicurarti che l'EA funzioni come previsto. Ricorda che il debugging e il testing sono essenziali per sviluppare un EA funzionante.

  3. User

    puoi riscrivere il codice migliorato e corretto da zero? magari dividilo in più messaggi

  4. Assistant

    Certo, rivedrò il codice della EA e apporterò correzioni come ho descritto. Inizierò con le dichiarazioni, le impostazioni iniziali e le funzioni di inizializzazione e disattivazione (init, deinit), e poi ci occuperemo delle funzioni del ciclo principale (start) e delle sue sottorutine.

    Parte 1: Dichiarazioni e Inizializzazione

    //+------------------------------------------------------------------+
    //|                                    SpudFrye Method I EA v001.mq4 |
    //|                              Copyright © 2007, NonDisclosure007. |
    //| Props to the following:                                          |
    //| Rob Rice (blueruby) for his indicator SpudFyre Stochs.mq4        |
    //+------------------------------------------------------------------+
    #include <stdlib.mqh>
    #include <stderror.mqh>
    
    // Dichiarazione delle variabili esterne
    extern double Lots = 1;                      // Dimensione del lotto standard
    
    // Controllo del profitto
    extern double StopLoss = 100;                // Massimo pip disposti a perdere per posizione
    extern bool UseTrailingStop = true;          // Se utilizzare Trailing Stop
    extern int TrailingStopType = 2;             // Tipo di Trailing Stop (1 immediato, 2 attesa)
    extern double TrailingStop = 25;             // Numero di pips per il trailing stop
    extern bool UseTakeProfit = false;           // Se utilizzare Take Profit
    extern int TakeProfit = 999;                 // Massimo livello di profitto raggiungibile
    extern int Slippage = 3;                     // Slittamento possibile
    
    // Intestazioni di etichettatura trade
    string label = "== scegli 15, 30, 60, 240 (4 ore) per timeframe di uscita";
    extern int exittimeframe = 30;               // Timeframe di uscita
    
    // Variabili interne
    double lowlimit = 20;
    double highlimit = 80;
    double myStopLoss;  
    double lotMM; 
    int MagicNumber;
    string setup = "";
    
    // Riprova impostazioni
    int totalTries = 5; 
    int retryDelay = 1000;
    
    // Debugging
    bool Debug=false;
    
    //+------------------------------------------------------------------+
    //| Funzione di init()                                               |
    //+------------------------------------------------------------------+
    int init() {
        MagicNumber = 5000 + Symbol2Val(Symbol()) * 100 + TimeFrame_Const2Val(Period()); 
        setup = "Stoch 5 EA " + Symbol() + "_" + TimeFrame_Val2String(TimeFrame_Const2Val(Period()));
        return(0);
    }
    
    //+------------------------------------------------------------------+
    //| Funzione di deinit()                                             |
    //+------------------------------------------------------------------+
    int deinit() {
        // Qui potresti implementare la pulizia delle risorse se necessario
        return(0);
    }
    

    Proseguirò con l’implementazione del ciclo di trading e delle funzioni di supporto nel messaggio seguente.

  5. User

    continua

  6. Assistant

    Parte 2: Ciclo di Trading e Funzioni del Ciclo Principale

    Continueremo con la funzione start, che gestisce il ciclo di trading principale e le sue sotto-funzioni.

    //+------------------------------------------------------------------+
    //| Funzione start()                                                 |
    //+------------------------------------------------------------------+
    int start() {
      BeginHandleStopLoss();
      if (NewBar()) {
          HandleOpenPositions();
          if (CheckOpenPositions() > 0) {
             return(0);
          }
          lotMM = Lots;
          if(BuySignal()) {
             OpenBuyOrder();
             return(0);
          }
          else if(SellSignal()) {
             OpenSellOrder();
             return(0);
          }
      }
      return(0);
    }
    
    //+------------------------------------------------------------------+
    //| Delinea se c'è una nuova barra                                   |
    //+------------------------------------------------------------------+
    bool NewBar() {
       static datetime lastBarTime = 0;
       if (Time[0] != lastBarTime) {
          lastBarTime = Time[0];
          return(true);
       } else {
          return(false);
       }
    }
    
    //+------------------------------------------------------------------+
    //| Gestisce il trailing stop per tutte le posizioni                 |
    //+------------------------------------------------------------------+
    int BeginHandleStopLoss() {
       for (int cnt = OrdersTotal() - 1; cnt >= 0; cnt--) {
          if (!OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES)) continue;
          if (OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber) continue;
          
          if (OrderType() == OP_BUY || OrderType() == OP_SELL) {
             if (UseTrailingStop) {
                HandleTrailingStop(OrderType(),OrderTicket(),OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit());
             }
          }
       }
       return(0);
    }
    
    //+------------------------------------------------------------------+
    //| Segnale di acquisto tramite analisi dello stocastico            |
    //+------------------------------------------------------------------+
    bool BuySignal() {
       if (StochOpen("Long")) return(true);
       return(false);   
    }
    
    //+------------------------------------------------------------------+
    //| Segnale di vendita tramite analisi dello stocastico              |
    //+------------------------------------------------------------------+
    bool SellSignal() {
       if (StochOpen("Short")) return(true);
       return(false);   
    }
    
    // Seguiranno le definizioni delle funzioni OpenBuyOrder, OpenSellOrder, 
    // StochOpen, HandleOpenPositions, e così via...
    

    Nella parte successiva, definiremo le funzioni finali che includeranno OpenBuyOrder, OpenSellOrder, StochOpen e HandleOpenPositions. Resta sintonizzato per il prossimo segmento del codice.

  7. User

    procedi

  8. Assistant

    Parte 3: Implementazione delle Funzioni di Apertura Ordini e Analisi Stocastica

    //+------------------------------------------------------------------+
    //| Apertura di un ordine di acquisto                                |
    //+------------------------------------------------------------------+
    void OpenBuyOrder() {
       double myPrice = MarketInfo(Symbol(), MODE_ASK);
       double myStopLoss = 0;
       
       if (StopLoss > 0) myStopLoss = myPrice - StopLoss * Point;
       myStopLoss = ValidStopLoss(OP_BUY, myStopLoss); 
       
       double myTakeProfit = 0;
       if (UseTakeProfit && TakeProfit > 0) myTakeProfit = myPrice + TakeProfit * Point;
       
       myPrice = NormalizeDouble(myPrice, Digits);
       myStopLoss = NormalizeDouble(myStopLoss, Digits);
       myTakeProfit = NormalizeDouble(myTakeProfit, Digits);
       
       int ticket = OrderSend(Symbol(), OP_BUY, lotMM, myPrice, Slippage, myStopLoss, myTakeProfit, setup,
                                                           MagicNumber, 0, clrGreen); // Verifica il colore: clrGreen esiste in MQL
       
       // Verifica la corretta apertura dell'ordine
       if (ticket < 0) {
          int err = GetLastError();
          if (Debug) {
             Print("Errore nell'apertura dell'ordine BUY: ", err, " ", ErrorDescription(err));
          }
          return; // Nessun bisogno di "return(0)" in una funzione void
       }
    
       if (Debug) {
          Print("Ordine BUY aperto: ", ticket);
       }
    }
    
    //+------------------------------------------------------------------+
    //| Apertura di un ordine di vendita                                 |
    //+------------------------------------------------------------------+
    void OpenSellOrder() {
       double myPrice = MarketInfo(Symbol(), MODE_BID);
       double myStopLoss = 0;
       
       if (StopLoss > 0) myStopLoss = myPrice + StopLoss * Point;
       myStopLoss = ValidStopLoss(OP_SELL, myStopLoss);
       
       double myTakeProfit = 0;
       if (UseTakeProfit && TakeProfit > 0) myTakeProfit = myPrice - TakeProfit * Point;
    
       myPrice = NormalizeDouble(myPrice, Digits);
       myStopLoss = NormalizeDouble(myStopLoss, Digits);
       myTakeProfit = NormalizeDouble(myTakeProfit, Digits);
       
       int ticket = OrderSend(Symbol(), OP_SELL, lotMM, myPrice, Slippage, myStopLoss, myTakeProfit, setup,
                                                           MagicNumber, 0, clrRed);
    
       // Verifica la corretta apertura dell'ordine
       if (ticket < 0) {
          int err = GetLastError();
          if (Debug) {
              Print("Errore nell'apertura dell'ordine SELL: ", err, " ", ErrorDescription(err));
          }
          return; // Nessun bisogno di "return(0)" in una funzione void
       }
    
       if (Debug) {
          Print("Ordine SELL aperto: ", ticket);
       }
    }
    
    //+------------------------------------------------------------------+
    //| Analisi Stocastica per i segnali di apertura ordini              |
    //+------------------------------------------------------------------+
    bool StochOpen(string signal) {
       double main = iStochastic(NULL, 0, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
       double main_last = iStochastic(NULL, 0, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 2);
       
       if (signal == "Long" && main > main_last && main_last < lowlimit) {
          return true;
       }
       if (signal == "Short" && main < main_last && main_last > highlimit) {
          return true;
       }
       return false;
    }
    
    // Gli altri comandi... 
    
    

    Nel prossimo messaggio, definirò le altre funzioni operative: HandleOpenPositions, HandleTrailingStop, ValidStopLoss e qualsiasi altro helper mancante.

  9. User

    continua

  10. Assistant

    Parte 4: Implementazione delle Funzioni di Gestione delle Posizioni e Assistenza

    //+------------------------------------------------------------------+
    //| Gestione delle posizioni aperte                                  |
    //+------------------------------------------------------------------+
    int HandleOpenPositions() {
       for (int cnt = OrdersTotal() - 1; cnt >= 0; cnt--) {
          if (!OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES)) continue;
          if (OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber) continue;
          
          if (OrderType() == OP_BUY) {
              // Qui potrebbe andare la logica di uscita per il BUY se necessaria
          } else if (OrderType() == OP_SELL) {
              // E qui quella di uscita per il SELL se necessaria
          }
       }
       return(0);
    }
    
    //+------------------------------------------------------------------+
    //| Trailing stop effettivo per una posizione                        |
    //+------------------------------------------------------------------+
    void HandleTrailingStop(int tradeType, int ticket, double openPrice, double currentStop, double currentTP) {
       double point = MarketInfo(Symbol(), MODE_POINT);
       double newStop = 0;
    
       // Determinazione del nuovo valore dello stop per il tipo di trade
       if (tradeType == OP_BUY) {
           double trailStopLevel = openPrice + TrailingStop * point;
           if (Bid >= trailStopLevel) {
               newStop = Bid - TrailingStop * point;
           }
       } else if (tradeType == OP_SELL) {
           double trailStopLevel = openPrice - TrailingStop * point;
           if (Ask <= trailStopLevel) {
               newStop = Ask + TrailingStop * point;
           }
       }
    
       newStop = NormalizeDouble(newStop, Digits);
    
       if (newStop > 0 && newStop != currentStop) {
           // Modifica l'ordine con il nuovo stop loss
           OrderModify(ticket, openPrice, newStop, currentTP, 0, clrNONE);
           if (Debug) {
               Print("Trailing Stop modificato per il ticket ", ticket, " nuovo stop a ", newStop);
           }
       }
    }
    
    //+------------------------------------------------------------------+
    //| Verifica che lo stop loss sia valido e lo normalizza             |
    //+------------------------------------------------------------------+
    double ValidStopLoss(int tradeType, double proposedStop) {
       double minStopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * MarketInfo(Symbol(), MODE_POINT);
    
       // Ajusta lo stop loss proposto a seconda se è BUY o SELL
       if (tradeType == OP_BUY && proposedStop < Ask - minStopLevel) {
           return (Ask - minStopLevel);
       } else if (tradeType == OP_SELL && proposedStop > Bid + minStopLevel) {
           return (Bid + minStopLevel);
       }
       return(proposedStop);
    }
    
    //+------------------------------------------------------------------+
    //| Indicatori ausiliari                                             |
    //+------------------------------------------------------------------+
    int TimeFrame_Const2Val(int tf){
       // Implementazione rimane invariata come nel codice originale
       // ...
    }
    
    string TimeFrame_Val2String(int val){
       // Implementazione rimane invariata come nel codice originale
       // ...
    }
    
    int Symbol2Val(string symbol) {
       // Implementazione rimane invariata come nel codice originale
       // ...
    }
    

    Queste funzioni formano la base della gestione trading logica della EA. Ho sistemato le logiche per la gestione dello stop e modificato la logica della verifica dello stop loss per essere più accurata.

    Assicurati di testare le funzioni corrette in un ambiente di test/sandbox prima di andare live in quanto la programmazione MQL4 può avere conseguenze finanziarie se non gestita correttamente.

    Spero sia tutto chiaro, ma se hai altre domande o hai bisogno di ulteriori modifiche, fammelo sapere!

  11. User

    //±-----------------------------------------------------------------+ //| SpudFrye Method EA v001.mq4 | //| Copyright © 2024, G.Bassi | //±-----------------------------------------------------------------+ #include <stdlib.mqh> #include <stderror.mqh>

    // Dichiarazione delle variabili esterne extern double Lots = 1; // Dimensione del lotto standard

    // Controllo del profitto extern double StopLoss = 100; // Massimo pip disposti a perdere per posizione extern bool UseTrailingStop = true; // Se utilizzare Trailing Stop extern int TrailingStopType = 2; // Tipo di Trailing Stop (1 immediato, 2 attesa) extern double TrailingStop = 25; // Numero di pips per il trailing stop extern bool UseTakeProfit = false; // Se utilizzare Take Profit extern int TakeProfit = 999; // Massimo livello di profitto raggiungibile extern int Slippage = 3; // Slittamento possibile

    // Intestazioni di etichettatura trade string label = "== scegli 15, 30, 60, 240 (4 ore) per timeframe di uscita"; extern int exittimeframe = 30; // Timeframe di uscita

    // Variabili interne double lowlimit = 20; double highlimit = 80; double myStopLoss;
    double lotMM; int MagicNumber; string setup = "";

    // Riprova impostazioni int totalTries = 5; int retryDelay = 1000;

    // Debugging bool Debug=false;

    //±-----------------------------------------------------------------+ //| Funzione di init() | //±-----------------------------------------------------------------+ int init() { MagicNumber = 5000 + Symbol2Val(Symbol()) * 100 + TimeFrame_Const2Val(Period()); setup = "Stoch 5 EA " + Symbol() + "_" + TimeFrame_Val2String(TimeFrame_Const2Val(Period())); return(0); }

    //±-----------------------------------------------------------------+ //| Funzione di deinit() | //±-----------------------------------------------------------------+ int deinit() { // Qui potresti implementare la pulizia delle risorse se necessario return(0); } //±-----------------------------------------------------------------+ //| Funzione start() | //±-----------------------------------------------------------------+ int start() { BeginHandleStopLoss(); if (NewBar()) { HandleOpenPositions(); if (CheckOpenPositions() > 0) { return(0); } lotMM = Lots; if(BuySignal()) { OpenBuyOrder(); return(0); } else if(SellSignal()) { OpenSellOrder(); return(0); } } return(0); }

    //±-----------------------------------------------------------------+ //| Delinea se c’è una nuova barra | //±-----------------------------------------------------------------+ bool NewBar() { static datetime lastBarTime = 0; if (Time[0] != lastBarTime) { lastBarTime = Time[0]; return(true); } else { return(false); } }

    //±-----------------------------------------------------------------+ //| Gestisce il trailing stop per tutte le posizioni | //±-----------------------------------------------------------------+ int BeginHandleStopLoss() { for (int cnt = OrdersTotal() - 1; cnt >= 0; cnt–) { if (!OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES)) continue; if (OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber) continue;

      if (OrderType() == OP_BUY || OrderType() == OP_SELL) {
         if (UseTrailingStop) {
            HandleTrailingStop(OrderType(),OrderTicket(),OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit());
         }
      }
    

    } return(0); }

    //±-----------------------------------------------------------------+ //| Segnale di acquisto tramite analisi dello stocastico | //±-----------------------------------------------------------------+ bool BuySignal() { if (StochOpen("Long")) return(true); return(false);
    }

    //±-----------------------------------------------------------------+ //| Segnale di vendita tramite analisi dello stocastico | //±-----------------------------------------------------------------+ bool SellSignal() { if (StochOpen("Short")) return(true); return(false);
    } //±-----------------------------------------------------------------+ //| Apertura di un ordine di acquisto | //±-----------------------------------------------------------------+ void OpenBuyOrder() { double myPrice = MarketInfo(Symbol(), MODE_ASK); double myStopLoss = 0;

    if (StopLoss > 0) myStopLoss = myPrice - StopLoss * Point; myStopLoss = ValidStopLoss(OP_BUY, myStopLoss);

    double myTakeProfit = 0; if (UseTakeProfit && TakeProfit > 0) myTakeProfit = myPrice + TakeProfit * Point;

    myPrice = NormalizeDouble(myPrice, Digits); myStopLoss = NormalizeDouble(myStopLoss, Digits); myTakeProfit = NormalizeDouble(myTakeProfit, Digits);

    int ticket = OrderSend(Symbol(), OP_BUY, lotMM, myPrice, Slippage, myStopLoss, myTakeProfit, setup, MagicNumber, 0, clrGreen); // Verifica il colore: clrGreen esiste in MQL

    // Verifica la corretta apertura dell’ordine if (ticket < 0) { int err = GetLastError(); if (Debug) { Print("Errore nell’apertura dell’ordine BUY: ", err, " ", ErrorDescription(err)); } return; // Nessun bisogno di "return(0)" in una funzione void }

    if (Debug) { Print("Ordine BUY aperto: ", ticket); } }

    //±-----------------------------------------------------------------+ //| Apertura di un ordine di vendita | //±-----------------------------------------------------------------+ void OpenSellOrder() { double myPrice = MarketInfo(Symbol(), MODE_BID); double myStopLoss = 0;

    if (StopLoss > 0) myStopLoss = myPrice + StopLoss * Point; myStopLoss = ValidStopLoss(OP_SELL, myStopLoss);

    double myTakeProfit = 0; if (UseTakeProfit && TakeProfit > 0) myTakeProfit = myPrice - TakeProfit * Point;

    myPrice = NormalizeDouble(myPrice, Digits); myStopLoss = NormalizeDouble(myStopLoss, Digits); myTakeProfit = NormalizeDouble(myTakeProfit, Digits);

    int ticket = OrderSend(Symbol(), OP_SELL, lotMM, myPrice, Slippage, myStopLoss, myTakeProfit, setup, MagicNumber, 0, clrRed);

    // Verifica la corretta apertura dell’ordine if (ticket < 0) { int err = GetLastError(); if (Debug) { Print("Errore nell’apertura dell’ordine SELL: ", err, " ", ErrorDescription(err)); } return; // Nessun bisogno di "return(0)" in una funzione void }

    if (Debug) { Print("Ordine SELL aperto: ", ticket); } }

    //±-----------------------------------------------------------------+ //| Analisi Stocastica per i segnali di apertura ordini | //±-----------------------------------------------------------------+ bool StochOpen(string signal) { double main = iStochastic(NULL, 0, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 1); double main_last = iStochastic(NULL, 0, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 2);

    if (signal == "Long" && main > main_last && main_last < lowlimit) { return true; } if (signal == "Short" && main < main_last && main_last > highlimit) { return true; } return false; } //±-----------------------------------------------------------------+ //| Gestione delle posizioni aperte | //±-----------------------------------------------------------------+ int HandleOpenPositions() { for (int cnt = OrdersTotal() - 1; cnt >= 0; cnt–) { if (!OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES)) continue; if (OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber) continue;

      if (OrderType() == OP_BUY) {
          // Qui potrebbe andare la logica di uscita per il BUY se necessaria
      } else if (OrderType() == OP_SELL) {
          // E qui quella di uscita per il SELL se necessaria
      }
    

    } return(0); }

    //±-----------------------------------------------------------------+ //| Trailing stop effettivo per una posizione | //±-----------------------------------------------------------------+ void HandleTrailingStop(int tradeType, int ticket, double openPrice, double currentStop, double currentTP) { double point = MarketInfo(Symbol(), MODE_POINT); double newStop = 0;

    // Determinazione del nuovo valore dello stop per il tipo di trade if (tradeType == OP_BUY) { double trailStopLevel = openPrice + TrailingStop * point; if (Bid >= trailStopLevel) { newStop = Bid - TrailingStop * point; } } else if (tradeType == OP_SELL) { double trailStopLevel = openPrice - TrailingStop * point; if (Ask <= trailStopLevel) { newStop = Ask + TrailingStop * point; } }

    newStop = NormalizeDouble(newStop, Digits);

    if (newStop > 0 && newStop != currentStop) { // Modifica l’ordine con il nuovo stop loss OrderModify(ticket, openPrice, newStop, currentTP, 0, clrNONE); if (Debug) { Print("Trailing Stop modificato per il ticket ", ticket, " nuovo stop a ", newStop); } } }

    //±-----------------------------------------------------------------+ //| Verifica che lo stop loss sia valido e lo normalizza | //±-----------------------------------------------------------------+ double ValidStopLoss(int tradeType, double proposedStop) { double minStopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * MarketInfo(Symbol(), MODE_POINT);

    // Ajusta lo stop loss proposto a seconda se è BUY o SELL if (tradeType == OP_BUY && proposedStop < Ask - minStopLevel) { return (Ask - minStopLevel); } else if (tradeType == OP_SELL && proposedStop > Bid + minStopLevel) { return (Bid + minStopLevel); } return(proposedStop); } //±-----------------------------------------------------------------+ //| Indicatori ausiliari | //±-----------------------------------------------------------------+ int TimeFrame_Const2Val(int Constant ) { switch(Constant) { case 1:
    return(1); case 5:
    return(2); case 15: return(3); case 30: return(4); case 60: return(5); case 240: return(6); case 1440: return(7); case 10080: return(8); case 43200: return(9); } } //+------------------------------------------------------------------+ //| Time frame string appropriation function | //+------------------------------------------------------------------+ string TimeFrame_Val2String(int Value ) { switch(Value) { case 1:
    return("PERIOD_M1"); case 2:
    return("PERIOD_M5"); case 3: return("PERIOD_M15"); case 4: return("PERIOD_M30"); case 5: return("PERIOD_H1"); case 6: return("PERIOD_H4"); case 7: return("PERIOD_D1"); case 8: return("PERIOD_W1"); case 9: return("PERIOD_MN1"); default: return("undefined " + Value); } } int Symbol2Val(string symbol) { string mySymbol = StringSubstr(symbol,0,6); if(mySymbol=="AUDCAD") return(1); if(mySymbol=="AUDJPY") return(2); if(mySymbol=="AUDNZD") return(3); if(mySymbol=="AUDUSD") return(4); if(mySymbol=="CHFJPY") return(5); if(mySymbol=="EURAUD") return(6); if(mySymbol=="EURCAD") return(7); if(mySymbol=="EURCHF") return(8); if(mySymbol=="EURGBP") return(9); if(mySymbol=="EURJPY") return(10); if(mySymbol=="EURUSD") return(11); if(mySymbol=="GBPCHF") return(12); if(mySymbol=="GBPJPY") return(13); if(mySymbol=="GBPUSD") return(14); if(mySymbol=="NZDUSD") return(15); if(mySymbol=="USDCAD") return(16); if(mySymbol=="USDCHF") return(17); if(mySymbol=="USDJPY") return(18); return(19); }

    questo è il codice completo che abbiamo scritto. ci sono degli errori: 'CheckOpenPositions' - function not defined SpudFrye Method II EA(1).mq4 62 11 'trailStopLevel' - variable already defined SpudFrye Method II EA(1).mq4 237 15

  12. Assistant

    Grazie per evidenziare questi errori. Diamo un'occhiata e apportiamo le modifiche necessarie al codice.

    Errore 1: La funzione CheckOpenPositions non è definita nel codice che hai fornito. Bisogna definirla per contare il numero di posizioni aperte con lo stesso MagicNumber.

    Errore 2: Il nome della variabile trailStopLevel è duplicato nella funzione HandleTrailingStop. Questo errore si verifica perché abbiamo definito trailStopLevel sia per gli ordini di tipo OP_BUY che OP_SELL. Dobbiamo utilizzare nomi di variabili univoci per ciascun tipo di ordine.

    Correggiamo i due errori nel codice:

    Parte 1: Definizione della Funzione CheckOpenPositions

    //+------------------------------------------------------------------+
    //| Controlla le posizioni aperte                                    |
    //+------------------------------------------------------------------+
    int CheckOpenPositions() {
       int NumBuyTrades = 0, NumSellTrades = 0;
       for (int i = 0; i < OrdersTotal(); i++) {
          if (!OrderSelect(i, SELECT_BY_POS, MODE_TRADES) ||
              OrderSymbol() != Symbol() || 
              OrderMagicNumber() != MagicNumber) continue;
          
          if (OrderType() == OP_BUY) NumBuyTrades++;
          if (OrderType() == OP_SELL) NumSellTrades++;
       }
       return (NumBuyTrades + NumSellTrades);
    }
    

    Parte 2: Correzione della Funzione HandleTrailingStop

    //+------------------------------------------------------------------+
    //| Trailing stop effettivo per una posizione                        |
    //+------------------------------------------------------------------+
    void HandleTrailingStop(int tradeType, int ticket, double openPrice, double currentStop, double currentTP) {
       double point = MarketInfo(Symbol(), MODE_POINT);
       double newStop;
    
       if (tradeType == OP_BUY) {
           double buyTrailStopLevel = openPrice + TrailingStop * point;
           if (Bid >= buyTrailStopLevel) {
               newStop = Bid - TrailingStop * point;
               newStop = NormalizeDouble(newStop, Digits);
               if (newStop != currentStop) {
                   OrderModify(ticket, openPrice, newStop, currentTP, 0, clrNONE);
                   if (Debug) Print("Modificato il Trailing Stop BUY per il ticket ", ticket);
               }
           }
       } else if (tradeType == OP_SELL) {
           double sellTrailStopLevel = openPrice - TrailingStop * point;
           if (Ask <= sellTrailStopLevel) {
               newStop = Ask + TrailingStop * point;
               newStop = NormalizeDouble(newStop, Digits);
               if (newStop != currentStop) {
                   OrderModify(ticket, openPrice, newStop, currentTP, 0, clrNONE);
                   if (Debug) Print("Modificato il Trailing Stop SELL per il ticket ", ticket);
               }
           }
       }
    }
    

    In questi pezzi di codice, abbiamo definito la funzione CheckOpenPositions e corretto l'errore di variabile duplicata in HandleTrailingStop. Ora integra queste correzioni nel tuo codice.

    Prima di eseguire l'EA, assicurati che ogni parte del codice sia integrata correttamente e che non ci siano altre incongruenze o problemi. É sempre consigliato eseguire un test su un ambiente demo per verificare la logica dell'EA prima di utilizzarlo in un ambiente di trading reale.

  13. User

    dove devo mettere la funzione CheckOpenPositions ?

  14. Assistant

    Nel codice di un Expert Advisor MetaTrader 4 (EA), le funzioni possono essere posizionate nella maggior parte dei casi in qualunque punto al di fuori di altre funzioni, purché siano all'interno della stessa sezione del file. Tuttavia, per ragioni di leggibilità e organizzazione, è consigliabile inserire le funzioni ausiliarie - come CheckOpenPositions - prima della funzione start, o dopo le definizioni di init e deinit e altre funzioni di inizializzazione. Inoltre, è necessario assicurarsi che ogni funzione sia definita prima del suo primo punto di chiamata nel codice.

    Ecco dove potresti inserire la funzione CheckOpenPositions:

    //+------------------------------------------------------------------+
    //| Funzione di deinit()                                             |
    //+------------------------------------------------------------------+
    int deinit() {
        // Qui potresti implementare la pulizia delle risorse se necessario
        return(0);
    }
    
    //+------------------------------------------------------------------+
    //| Controlla le posizioni aperte                                    |
    //+------------------------------------------------------------------+
    int CheckOpenPositions() {
       int NumBuyTrades = 0, NumSellTrades = 0;
       for (int i = 0; i < OrdersTotal(); i++) {
          if (!OrderSelect(i, SELECT_BY_POS, MODE_TRADES) ||
              OrderSymbol() != Symbol() || 
              OrderMagicNumber() != MagicNumber) continue;
          
          if (OrderType() == OP_BUY) NumBuyTrades++;
          if (OrderType() == OP_SELL) NumSellTrades++;
       }
       return (NumBuyTrades + NumSellTrades);
    }
    
    //+------------------------------------------------------------------+
    //| Funzione start()                                                 |
    //+------------------------------------------------------------------+
    int start() {
      // Il resto del codice...
    }
    

    Aggiungendo la funzione CheckOpenPositions prima della funzione start ci assicuriamo che sia definita e pronta per essere chiamata all'interno della funzione start. Ricorda di testare sempre il codice su un account demo per assicurarti che funzioni come previsto prima di eseguirlo su un conto reale.

  15. User

    il tester dice 2024.01.20 17:32:17.123 2023.12.29 22:45:00 SpudFrye Method II EA(1) EURUSD,M15: OrderSend error 130

  16. Assistant

    L'errore 130 in MetaTrader 4 indica un "invalid stops" error, il che significa che uno o più valori inseriti per gli stop loss, take profit o il prezzo di apertura di un ordine non soddisfano i requisiti minimi del broker o non sono in linea con le regole di trading del mercato su cui stai facendo trading. Questo può avvenire per vari motivi:

    1. Livello di Stop Minimo: Il livello di stop (stop loss o take profit) che hai impostato potrebbe essere troppo vicino al prezzo di mercato corrente. MT4 impone limiti su quanto vicino gli stop loss e i take profit possono essere impostati al prezzo di mercato corrente. Questo è conosciuto come il "Stop Level". Per risolvere questo problema, aumenta la distanza tra il prezzo corrente e il tuo stop loss o take profit.

    2. Allineamento del Pip: In alcuni casi, lo stop loss o il take profit non sono allineati con il numero appropriato di decimali o "pips" consentiti per la tua coppia di valute. Usa la funzione NormalizeDouble per allineare il tuo stop loss e il take profit al numero di decimali corretto per il simbolo.

    3. Norme di Arrotondamento: Gli ordini devono essere arrotondati correttamente in base alla dimensione minima dell'incremento del prezzo (nota come "tick size"). Anche questo può essere ottenuto tramite la funzione NormalizeDouble.

    Ecco un esempio di come puoi usare NormalizeDouble e controllare il livello di stop minimo:

    double stopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL);
    double point = MarketInfo(Symbol(), MODE_POINT);
    double minStopLoss = Ask + stopLevel * point; // Per ordini di acquisto (OP_BUY)
    double maxStopLoss = Bid - stopLevel * point; // Per ordini di vendita (OP_SELL)
    
    // Arrotondamento allo stop loss valido
    if (OrderType() == OP_BUY) {
       myStopLoss = max(myStopLoss, minStopLoss);
    } else if (OrderType() == OP_SELL) {
       myStopLoss = min(myStopLoss, maxStopLoss);
    }
    
    // Normalizzazione
    myStopLoss = NormalizeDouble(myStopLoss, Digits);
    myTakeProfit = NormalizeDouble(myTakeProfit, Digits);
    

    Importante nell'uso di NormalizeDouble, dove Digits è il numero di cifre decimali usate nel prezzo del simbolo corrente (in genere 4 o 5 per i maggiori Forex pairs, o 2-3 per JPY pairs).

    Inoltre, controlla la funzione ValidStopLoss nel tuo EA per assicurarti che stia facendo il controllo adeguato dei limiti dello stop loss.

    Dopo aver apportato le modifiche, testa nuovamente l'EA nel Strategy Tester per assicurarti che l'errore non si verifichi più.

  17. User

    fai le modifiche con normalizedouble al codice che abbiamo scritto //±-----------------------------------------------------------------+ //| SpudFrye Method EA v001.mq4 | //| Copyright © 2024, G.Bassi | //±-----------------------------------------------------------------+ #include <stdlib.mqh> #include <stderror.mqh>

    // Dichiarazione delle variabili esterne extern double Lots = 1; // Dimensione del lotto standard

    // Controllo del profitto extern double StopLoss = 100; // Massimo pip disposti a perdere per posizione extern bool UseTrailingStop = true; // Se utilizzare Trailing Stop extern int TrailingStopType = 2; // Tipo di Trailing Stop (1 immediato, 2 attesa) extern double TrailingStop = 25; // Numero di pips per il trailing stop extern bool UseTakeProfit = false; // Se utilizzare Take Profit extern int TakeProfit = 999; // Massimo livello di profitto raggiungibile extern int Slippage = 3; // Slittamento possibile

    // Intestazioni di etichettatura trade string label = "== scegli 15, 30, 60, 240 (4 ore) per timeframe di uscita"; extern int exittimeframe = 30; // Timeframe di uscita

    // Variabili interne double lowlimit = 20; double highlimit = 80; double myStopLoss;
    double lotMM; int MagicNumber; string setup = "";

    // Riprova impostazioni int totalTries = 5; int retryDelay = 1000;

    // Debugging bool Debug=false;

    //±-----------------------------------------------------------------+ //| Funzione di init() | //±-----------------------------------------------------------------+ int init() { MagicNumber = 5000 + Symbol2Val(Symbol()) * 100 + TimeFrame_Const2Val(Period()); setup = "Stoch 5 EA " + Symbol() + "_" + TimeFrame_Val2String(TimeFrame_Const2Val(Period())); return(0); }

    //±-----------------------------------------------------------------+ //| Funzione di deinit() | //±-----------------------------------------------------------------+ int deinit() { // Qui potresti implementare la pulizia delle risorse se necessario return(0); }

    //±-----------------------------------------------------------------+ //| Controlla le posizioni aperte | //±-----------------------------------------------------------------+ int CheckOpenPositions() { int NumBuyTrades = 0, NumSellTrades = 0; for (int i = 0; i < OrdersTotal(); i++) { if (!OrderSelect(i, SELECT_BY_POS, MODE_TRADES) || OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber) continue;

      if (OrderType() == OP_BUY) NumBuyTrades++;
      if (OrderType() == OP_SELL) NumSellTrades++;
    

    } return (NumBuyTrades + NumSellTrades); }

    //±-----------------------------------------------------------------+ //| Funzione start() | //±-----------------------------------------------------------------+ int start() { BeginHandleStopLoss(); if (NewBar()) { HandleOpenPositions(); if (CheckOpenPositions() > 0) { return(0); } lotMM = Lots; if(BuySignal()) { OpenBuyOrder(); return(0); } else if(SellSignal()) { OpenSellOrder(); return(0); } } return(0); }

    //±-----------------------------------------------------------------+ //| Delinea se c’è una nuova barra | //±-----------------------------------------------------------------+ bool NewBar() { static datetime lastBarTime = 0; if (Time[0] != lastBarTime) { lastBarTime = Time[0]; return(true); } else { return(false); } }

    //±-----------------------------------------------------------------+ //| Gestisce il trailing stop per tutte le posizioni | //±-----------------------------------------------------------------+ int BeginHandleStopLoss() { for (int cnt = OrdersTotal() - 1; cnt >= 0; cnt--) { if (!OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES)) continue; if (OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber) continue;

      if (OrderType() == OP_BUY || OrderType() == OP_SELL) {
         if (UseTrailingStop) {
            HandleTrailingStop(OrderType(),OrderTicket(),OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit());
         }
      }
    

    } return(0); }

    //±-----------------------------------------------------------------+ //| Segnale di acquisto tramite analisi dello stocastico | //±-----------------------------------------------------------------+ bool BuySignal() { if (StochOpen("Long")) return(true); return(false);
    }

    //±-----------------------------------------------------------------+ //| Segnale di vendita tramite analisi dello stocastico | //±-----------------------------------------------------------------+ bool SellSignal() { if (StochOpen("Short")) return(true); return(false);
    } //±-----------------------------------------------------------------+ //| Apertura di un ordine di acquisto | //±-----------------------------------------------------------------+ void OpenBuyOrder() { double myPrice = MarketInfo(Symbol(), MODE_ASK); double myStopLoss = 0;

    if (StopLoss > 0) myStopLoss = myPrice - StopLoss * Point; myStopLoss = ValidStopLoss(OP_BUY, myStopLoss);

    double myTakeProfit = 0; if (UseTakeProfit && TakeProfit > 0) myTakeProfit = myPrice + TakeProfit * Point;

    myPrice = NormalizeDouble(myPrice, Digits); myStopLoss = NormalizeDouble(myStopLoss, Digits); myTakeProfit = NormalizeDouble(myTakeProfit, Digits);

    int ticket = OrderSend(Symbol(), OP_BUY, lotMM, myPrice, Slippage, myStopLoss, myTakeProfit, setup, MagicNumber, 0, clrGreen); // Verifica il colore: clrGreen esiste in MQL

    // Verifica la corretta apertura dell’ordine if (ticket < 0) { int err = GetLastError(); if (Debug) { Print("Errore nell’apertura dell’ordine BUY: ", err, " ", ErrorDescription(err)); } return; // Nessun bisogno di "return(0)" in una funzione void }

    if (Debug) { Print("Ordine BUY aperto: ", ticket); } }

    //±-----------------------------------------------------------------+ //| Apertura di un ordine di vendita | //±-----------------------------------------------------------------+ void OpenSellOrder() { double myPrice = MarketInfo(Symbol(), MODE_BID); double myStopLoss = 0;

    if (StopLoss > 0) myStopLoss = myPrice + StopLoss * Point; myStopLoss = ValidStopLoss(OP_SELL, myStopLoss);

    double myTakeProfit = 0; if (UseTakeProfit && TakeProfit > 0) myTakeProfit = myPrice - TakeProfit * Point;

    myPrice = NormalizeDouble(myPrice, Digits); myStopLoss = NormalizeDouble(myStopLoss, Digits); myTakeProfit = NormalizeDouble(myTakeProfit, Digits);

    int ticket = OrderSend(Symbol(), OP_SELL, lotMM, myPrice, Slippage, myStopLoss, myTakeProfit, setup, MagicNumber, 0, clrRed);

    // Verifica la corretta apertura dell’ordine if (ticket < 0) { int err = GetLastError(); if (Debug) { Print("Errore nell’apertura dell’ordine SELL: ", err, " ", ErrorDescription(err)); } return; // Nessun bisogno di "return(0)" in una funzione void }

    if (Debug) { Print("Ordine SELL aperto: ", ticket); } }

    //±-----------------------------------------------------------------+ //| Analisi Stocastica per i segnali di apertura ordini | //±-----------------------------------------------------------------+ bool StochOpen(string signal) { double main = iStochastic(NULL, 0, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 1); double main_last = iStochastic(NULL, 0, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 2);

    if (signal == "Long" && main > main_last && main_last < lowlimit) { return true; } if (signal == "Short" && main < main_last && main_last > highlimit) { return true; } return false; } //±-----------------------------------------------------------------+ //| Gestione delle posizioni aperte | //±-----------------------------------------------------------------+ int HandleOpenPositions() { for (int cnt = OrdersTotal() - 1; cnt >= 0; cnt--) { if (!OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES)) continue; if (OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber) continue;

      if (OrderType() == OP_BUY) {
          // Qui potrebbe andare la logica di uscita per il BUY se necessaria
      } else if (OrderType() == OP_SELL) {
          // E qui quella di uscita per il SELL se necessaria
      }
    

    } return(0); }

    //±-----------------------------------------------------------------+ //| Trailing stop effettivo per una posizione | //±-----------------------------------------------------------------+ void HandleTrailingStop(int tradeType, int ticket, double openPrice, double currentStop, double currentTP) { double point = MarketInfo(Symbol(), MODE_POINT); double newStop;

    if (tradeType == OP_BUY) { double buyTrailStopLevel = openPrice + TrailingStop * point; if (Bid >= buyTrailStopLevel) { newStop = Bid - TrailingStop * point; newStop = NormalizeDouble(newStop, Digits); if (newStop != currentStop) { OrderModify(ticket, openPrice, newStop, currentTP, 0, clrNONE); if (Debug) Print("Modificato il Trailing Stop BUY per il ticket ", ticket); } } } else if (tradeType == OP_SELL) { double sellTrailStopLevel = openPrice - TrailingStop * point; if (Ask <= sellTrailStopLevel) { newStop = Ask + TrailingStop * point; newStop = NormalizeDouble(newStop, Digits); if (newStop != currentStop) { OrderModify(ticket, openPrice, newStop, currentTP, 0, clrNONE); if (Debug) Print("Modificato il Trailing Stop SELL per il ticket ", ticket); } } } }

    //±-----------------------------------------------------------------+ //| Verifica che lo stop loss sia valido e lo normalizza | //±-----------------------------------------------------------------+ double ValidStopLoss(int tradeType, double proposedStop) { double minStopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * MarketInfo(Symbol(), MODE_POINT);

    // Ajusta lo stop loss proposto a seconda se è BUY o SELL if (tradeType == OP_BUY && proposedStop < Ask - minStopLevel) { return (Ask - minStopLevel); } else if (tradeType == OP_SELL && proposedStop > Bid + minStopLevel) { return (Bid + minStopLevel); } return(proposedStop); } //±-----------------------------------------------------------------+ //| Indicatori ausiliari | //±-----------------------------------------------------------------+ int TimeFrame_Const2Val(int Constant ) { switch(Constant) { case 1:
    return(1); case 5:
    return(2); case 15: return(3); case 30: return(4); case 60: return(5); case 240: return(6); case 1440: return(7); case 10080: return(8); case 43200: return(9); } } //+------------------------------------------------------------------+ //| Time frame string appropriation function | //+------------------------------------------------------------------+ string TimeFrame_Val2String(int Value ) { switch(Value) { case 1:
    return("PERIOD_M1"); case 2:
    return("PERIOD_M5"); case 3: return("PERIOD_M15"); case 4: return("PERIOD_M30"); case 5: return("PERIOD_H1"); case 6: return("PERIOD_H4"); case 7: return("PERIOD_D1"); case 8: return("PERIOD_W1"); case 9: return("PERIOD_MN1"); default: return("undefined " + Value); } } int Symbol2Val(string symbol) { string mySymbol = StringSubstr(symbol,0,6); if(mySymbol=="AUDCAD") return(1); if(mySymbol=="AUDJPY") return(2); if(mySymbol=="AUDNZD") return(3); if(mySymbol=="AUDUSD") return(4); if(mySymbol=="CHFJPY") return(5); if(mySymbol=="EURAUD") return(6); if(mySymbol=="EURCAD") return(7); if(mySymbol=="EURCHF") return(8); if(mySymbol=="EURGBP") return(9); if(mySymbol=="EURJPY") return(10); if(mySymbol=="EURUSD") return(11); if(mySymbol=="GBPCHF") return(12); if(mySymbol=="GBPJPY") return(13); if(mySymbol=="GBPUSD") return(14); if(mySymbol=="NZDUSD") return(15); if(mySymbol=="USDCAD") return(16); if(mySymbol=="USDCHF") return(17); if(mySymbol=="USDJPY") return(18); return(19); }

  18. Assistant

    Per risolvere il problema dell'errore 130, dobbiamo assicurarci che gli stop loss e i take profit siano validi e conformi ai requisiti del broker, e che il prezzo di apertura sia correttamente normalizzato. Facciamo le modifiche necessarie alle funzioni OpenBuyOrder e OpenSellOrder per includere la logica di normalizzazione:

    //±-----------------------------------------------------------------+
    //| Apertura di un ordine di acquisto                                |
    //±-----------------------------------------------------------------+
    void OpenBuyOrder() {
       double myPrice = MarketInfo(Symbol(), MODE_ASK);
       double myStopLoss = 0;
       double minStopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * MarketInfo(Symbol(), MODE_POINT);
    
       if (StopLoss > 0) {
           myStopLoss = myPrice - StopLoss * Point;
           myStopLoss = NormalizeDouble(myStopLoss, Digits);
           if (myStopLoss < Ask - minStopLevel) {
               myStopLoss = Ask - minStopLevel;
           }
       }
    
       double myTakeProfit = 0;
       if (UseTakeProfit && TakeProfit > 0) {
           myTakeProfit = myPrice + TakeProfit * Point;
           myTakeProfit = NormalizeDouble(myTakeProfit, Digits);
       }
       
       myPrice = NormalizeDouble(myPrice, Digits);
       
       int ticket = OrderSend(Symbol(), OP_BUY, lotMM, myPrice, Slippage, myStopLoss, myTakeProfit, setup, MagicNumber, 0, clrGreen);
    
       // Verifica la corretta apertura dell’ordine
       if (ticket < 0) {
          int err = GetLastError();
          if (Debug) {
             Print("Errore nell’apertura dell’ordine BUY: ", err, " ", ErrorDescription(err));
          }
       } else if (Debug) {
          Print("Ordine BUY aperto: ", ticket);
       }
    }
    
    //±-----------------------------------------------------------------+
    //| Apertura di un ordine di vendita                                 |
    //±-----------------------------------------------------------------+
    void OpenSellOrder() {
       double myPrice = MarketInfo(Symbol(), MODE_BID);
       double myStopLoss = 0;
       double minStopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * MarketInfo(Symbol(), MODE_POINT);
    
       if (StopLoss > 0) {
           myStopLoss = myPrice + StopLoss * Point;
           myStopLoss = NormalizeDouble(myStopLoss, Digits);
           if (myStopLoss > Bid + minStopLevel) {
               myStopLoss = Bid + minStopLevel;
           }
       }
    
       double myTakeProfit = 0;
       if (UseTakeProfit && TakeProfit > 0) {
           myTakeProfit = myPrice - TakeProfit * Point;
           myTakeProfit = NormalizeDouble(myTakeProfit, Digits);
       }
       
       myPrice = NormalizeDouble(myPrice, Digits);
       
       int ticket = OrderSend(Symbol(), OP_SELL, lotMM, myPrice, Slippage, myStopLoss, myTakeProfit, setup, MagicNumber, 0, clrRed);
    
       // Verifica la corretta apertura dell’ordine
       if (ticket < 0) {
          int err = GetLastError();
          if (Debug) {
              Print("Errore nell’apertura dell’ordine SELL: ", err, " ", ErrorDescription(err));
          }
       } else if (Debug) {
          Print("Ordine SELL aperto: ", ticket);
       }
    }
    

    Le modifiche includono il controllo del minStopLevel (livello di stop minimo) imposta dal broker e la normalizzazione dei valori di stop loss, take profit e prezzo con NormalizeDouble per assicurarsi che siano conformi ai requisiti di mercato.

    Assicurati che clrGreen e clrRed siano colori validi nella tua versione di MetaTrader 4 o sostituiscili con colori definiti come Green o Red.

    Una volta implementate queste modifiche, compila nuovamente l'EA e testalo con il Strategy Tester per vedere se l'errore 130 è stato risolto. Se l'errore persiste, potrebbe essere necessario regolare ulteriormente lo stop loss e il take profit o contattare il tuo broker per capire i loro specifici requisiti di trading.

  19. User

    2024.01.20 18:02:28.810 2023.12.29 21:15:05 SpudFrye Method II EA(1) EURUSD,M15: OrderSend error 130 l'errore persiste

  20. Assistant

    L'errore 130 in MetaTrader 4 significa che stai cercando di impostare il tuo stop loss o take profit vicino al prezzo di mercato corrente, oltre i limiti imposti dal broker.

    Per assicurarti che gli stop loss e i take profit siano impostati correttamente, è necessario interrogare il server per ottenere il livello minimo di stop (il valore di MODE_STOPLEVEL) e poi confrontare i tuoi stop loss e take profit proposti con questo livello minimo di stop per assicurarti che siano validi.

    Vediamo come implementare questo correttamente:

    double NormalizePrice(double price) {
       return(NormalizeDouble(price, Digits));
    }
    
    double GetMinStopLoss(double price, bool isBuy) {
       double minStopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * Point;
       if (isBuy) {
           // Per ordini di acquisto, lo stop loss non può essere inferiore al prezzo corrente più il minStopLevel
           return(NormalizePrice(price + minStopLevel));
       } else {
           // Per ordini di vendita, lo stop loss non può essere maggiore del prezzo corrente meno il minStopLevel
           return(NormalizePrice(price - minStopLevel));
       }
    }
    
    void OpenBuyOrder() {
       double ask = MarketInfo(Symbol(), MODE_ASK);
       double minStopLoss = GetMinStopLoss(ask, true);
    
       double myStopLoss = NormalizePrice(ask - StopLoss * Point);
       if(myStopLoss < minStopLoss) myStopLoss = minStopLoss;
    
       double myTakeProfit = 0;
       if (UseTakeProfit && TakeProfit > 0) {
           myTakeProfit = NormalizePrice(ask + TakeProfit * Point);
       }
    
       int ticket = OrderSend(Symbol(), OP_BUY, lotMM, ask, Slippage, myStopLoss, myTakeProfit, setup, MagicNumber, 0, clrGreen);
    
       // il resto del codice...
    }
    
    void OpenSellOrder() {
       double bid = MarketInfo(Symbol(), MODE_BID);
       double minStopLoss = GetMinStopLoss(bid, false);
    
       double myStopLoss = NormalizePrice(bid + StopLoss * Point);
       if (myStopLoss > minStopLoss) myStopLoss = minStopLoss;
    
       double myTakeProfit = 0;
       if (UseTakeProfit && TakeProfit > 0) {
           myTakeProfit = NormalizePrice(bid - TakeProfit * Point);
       }
    
       int ticket = OrderSend(Symbol(), OP_SELL, lotMM, bid, Slippage, myStopLoss, myTakeProfit, setup, MagicNumber, 0, clrRed);
    
       // il resto del codice...
    }
    

    In questo codice, abbiamo creato due funzioni aggiuntive: NormalizePrice, che normalizza il prezzo di mercato in base ai decimali (Digits) del simbolo, e GetMinStopLoss, che calcola e restituisce il valore minimo valido per lo stop loss dipendente se l'ordine è di acquisto (BUY) o vendita (SELL).

    Inoltre, assicurati che i valori di StopLoss e TakeProfit siano in pips e non in punti, specialmente se stai operando su una coppia di valute che ha un punto decimale a cinque cifre.

    Se l'errore persiste dopo l'implementazione di queste correzioni, potrebbe essere utile verificare con il broker i requisiti specifici per gli stop loss e i take profit, poiché possono variare per ogni broker o tipo di account.

  21. User

    dove devo inserire questo codice?

  22. Assistant

    Le modifiche che ho suggerito dovrebbero essere implementate nelle funzioni OpenBuyOrder e OpenSellOrder dove effettui la chiamata alla funzione OrderSend. Dovrai quindi anche aggiungere le nuove funzioni che ho creato (NormalizePrice e GetMinStopLoss) in una sezione appropriata del tuo file EA, di solito dopo le dichiarazioni di variabili globali ma prima delle funzioni di trading principali come start, OpenBuyOrder, e OpenSellOrder.

    Ecco come integrerai il codice:

    // ...
    
    // Dichiarazioni delle altre variabili e funzioni
    
    // Aggiungi le nuove funzioni helper qui
    double NormalizePrice(double price) {
       // Corpo della funzione NormalizePrice
       // ...
    }
    
    double GetMinStopLoss(double price, bool isBuy) {
       // Corpo della funzione GetMinStopLoss
       // ...
    }
    
    // ...  
    
    // Le tue funzioni di trading come OpenBuyOrder e OpenSellOrder
    void OpenBuyOrder() {
       // Corpo della funzione OpenBuyOrder modificato con 
       // le chiamate a NormalizePrice e GetMinStopLoss
       // ...
    }
    
    void OpenSellOrder() {
       // Corpo della funzione OpenSellOrder modificato con 
       // le chiamate a NormalizePrice e GetMinStopLoss
       // ...
    }
    
    //...
    
    // Funzione start() e le altre parti del tuo EA
    
    // ...
    

    Questo terrà il tuo codice organizzato e faciliterà la lettura e il debugging dell'EA. Ricorda sempre di testare qualsiasi cambiamento in un ambiente di test come il Strategy Tester di MetaTrader o un conto demo prima di eseguire l'EA su un conto di trading reale.

  23. User

    puoi riscrivere le funzioni OpenBuyOrder e OpenSellOrder per intero?

  24. Assistant

    Certo, ecco le funzioni riscritte OpenBuyOrder e OpenSellOrder con le modifiche necessarie per gestire correttamente gli stop loss e take profit e prevenire l'errore 130.

    //±-----------------------------------------------------------------+
    //| Apertura di un ordine di acquisto                                |
    //±-----------------------------------------------------------------+
    void OpenBuyOrder() {
       double ask = MarketInfo(Symbol(), MODE_ASK);
       double stopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * Point;
       double minStopLoss = ask + stopLevel; // Modifica dello stop level per BUY
       double minTakeProfit = ask + stopLevel; // Modifica dello take profit level per BUY
       
       double myStopLoss = NormalizeDouble((StopLoss > 0) ? max(minStopLoss, ask - StopLoss * Point) : 0, Digits);
       double myTakeProfit = NormalizeDouble((UseTakeProfit && TakeProfit > 0) ? ask + TakeProfit * Point : 0, Digits);
       
       int ticket = OrderSend(Symbol(), OP_BUY, Lots, ask, Slippage, myStopLoss, myTakeProfit, setup, MagicNumber, 0, clrGreen);
       
       if (ticket < 0) {
          Print("Error Opening BUY Order: ", GetLastError());
       } else {
          if (Debug) Print("BUY Order opened at ", ask);
       }
    }
    
    //±-----------------------------------------------------------------+
    //| Apertura di un ordine di vendita                                 |
    //±-----------------------------------------------------------------+
    void OpenSellOrder() {
       double bid = MarketInfo(Symbol(), MODE_BID);
       double stopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * Point;
       double maxStopLoss = bid - stopLevel; // Modifica dello stop level per SELL
       double maxTakeProfit = bid - stopLevel; // Modifica dello take profit level per SELL
       
       double myStopLoss = NormalizeDouble((StopLoss > 0) ? min(maxStopLoss, bid + StopLoss * Point) : 0, Digits);
       double myTakeProfit = NormalizeDouble((UseTakeProfit && TakeProfit > 0) ? bid - TakeProfit * Point : 0, Digits);
       
       int ticket = OrderSend(Symbol(), OP_SELL, Lots, bid, Slippage, myStopLoss, myTakeProfit, setup, MagicNumber, 0, clrRed);
       
       if (ticket < 0) {
          Print("Error Opening SELL Order: ", GetLastError());
       } else {
          if (Debug) Print("SELL Order opened at ", bid);
       }
    }
    

    Nelle funzioni, ho utilizzato la funzione NormalizeDouble per normalizzare i valori di StopLoss e TakeProfit in base al numero di decimali (Digits) specifico per il simbolo di trading corrente. Inoltre, ho verificato che lo StopLoss sia impostato al di fuori del livello di stop minimo consentito (MODE_STOPLEVEL), aggiungendo o sottraendo questo valore dal prezzo attuale nel caso di ordini di acquisto o vendita, rispettivamente.

    Ricorda di sostituire clrGreen e clrRed con i valori corretti per i colori se necessario conforme alla tua piattaforma MT4 (ad esempio Green o Red).

    Dopo aver apportato queste modifiche, compila nuovamente il tuo EA e testalo con il Strategy Tester per verificare che l'errore 130 sia stato risolto.

  25. User

    'max' - function not defined SpudFrye Method II EA(1).mq4 165 57 'min' - function not defined SpudFrye Method II EA(1).mq4 186 57

  26. Assistant

    Nel linguaggio MQL4, le funzioni min e max non sono funzioni native come in alcuni altri linguaggi di programmazione. Invece, utilizziamo una semplice logica condizionale per ottenere il valore minimo o massimo. Potremmo definire queste funzioni da zero o semplicemente usare le espressioni condizionali (a < b) ? a : b per min e (a > b) ? a : b per max.

    Vediamo come si modifica il codice per le funzioni OpenBuyOrder e OpenSellOrder senza usare min e max:

    //±-----------------------------------------------------------------+
    //| Apertura di un ordine di acquisto                                |
    //±-----------------------------------------------------------------+
    void OpenBuyOrder() {
        double ask = MarketInfo(Symbol(), MODE_ASK);
        double stopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * Point;
        double myStopLoss = ask - StopLoss * Point;
        myStopLoss = (myStopLoss > ask + stopLevel) ? myStopLoss : ask + stopLevel;
        myStopLoss = NormalizeDouble(myStopLoss, Digits);
    
        double myTakeProfit = 0;
        if (UseTakeProfit && TakeProfit > 0) {
            myTakeProfit = ask + TakeProfit * Point;
            myTakeProfit = NormalizeDouble(myTakeProfit, Digits);
        }
        
        int ticket = OrderSend(Symbol(), OP_BUY, Lots, ask, Slippage, myStopLoss, myTakeProfit, setup, MagicNumber, 0, clrGreen);
        
        if (ticket < 0) {
            Print("Error Opening BUY Order: ", GetLastError());
        } else {
            if (Debug) Print("BUY Order opened at ", ask);
        }
    }
    
    //±-----------------------------------------------------------------+
    //| Apertura di un ordine di vendita                                 |
    //±-----------------------------------------------------------------+
    void OpenSellOrder() {
        double bid = MarketInfo(Symbol(), MODE_BID);
        double stopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * Point;
        double myStopLoss = bid + StopLoss * Point;
        myStopLoss = (myStopLoss < bid - stopLevel) ? myStopLoss : bid - stopLevel;
        myStopLoss = NormalizeDouble(myStopLoss, Digits);
    
        double myTakeProfit = 0;
        if (UseTakeProfit && TakeProfit > 0) {
            myTakeProfit = bid - TakeProfit * Point;
            myTakeProfit = NormalizeDouble(myTakeProfit, Digits);
        }
        
        int ticket = OrderSend(Symbol(), OP_SELL, Lots, bid, Slippage, myStopLoss, myTakeProfit, setup, MagicNumber, 0, clrRed);
        
        if (ticket < 0) {
            Print("Error Opening SELL Order: ", GetLastError());
        } else {
            if (Debug) Print("SELL Order opened at ", bid);
        }
    }
    

    Nel codice sopra, la logica if-else è stata utilizzata per calcolare il valore minimo e massimo, seguendo la stessa funzionalità delle funzioni min e max.

    Sustituisci clrGreen e clrRed con colori validi se questi non sono predefiniti. Ad esempio, in alcune versioni di MQL4 potresti usare Green o Red o potresti dover definire le costanti di colore usando il loro valore ARGB.

  27. User

    cosa significa "not all control paths return a value SpudFrye Method II EA(1).mq4 307 1" si riferisce a int TimeFrame_Const2Val(int Constant ) { switch(Constant) { case 1:
    return(1); case 5:
    return(2); case 15: return(3); case 30: return(4); case 60: return(5); case 240: return(6); case 1440: return(7); case 10080: return(8); case 43200: return(9); } }

  28. Assistant

    L'errore "not all control paths return a value" significa che esiste un percorso logico nella tua funzione che non porta a una istruzione return. In altre parole, se nessuno dei casi nel blocco switch corrisponde al valore della variabile Constant, la funzione non restituisce alcun valore, ma essendo il tipo di ritorno dichiarato come int, è necessario che la funzione restituisca un valore in ogni possibile percorso di esecuzione.

    Per risolvere questo errore, puoi aggiungere un'istruzione default al blocco switch, che verrà eseguita se nessuno dei casi specificati corrisponde al valore dato:

    int TimeFrame_Const2Val(int Constant) {
        switch(Constant) {
            case 1:  
                return(1);
            case 5:  
                return(2);
            case 15:
                return(3);
            case 30:
                return(4);
            case 60:
                return(5);
            case 240:
                return(6);
            case 1440:
                return(7);
            case 10080:
                return(8);
            case 43200:
                return(9);
            default:
                return(-1); // Valore di default se nessun caso è stato abbinato
        }
    }
    

    In questo esempio, ho aggiunto un caso default che restituirà -1, che potrebbe rappresentare un valore non valido o un errore. Assicurati di gestire questo valore restituito di -1 in modo appropriato nel tuo codice, in modo tale da evitare di effettuare operazioni non valide con esso. Questa aggiunta di logica ti aiuterà a evitare questo tipo di errore assicurandoti che la funzione restituisca sempre un valore, a prescindere dal valore di input.

  29. User

    non ci siamo ancora 2024.01.20 18:26:00.621 2023.12.29 14:00:00 SpudFrye Method II EA(1) EURUSD,M15: Error Opening SELL Order: 130 2024.01.20 18:26:00.621 2023.12.29 15:30:00 SpudFrye Method II EA(1) EURUSD,M15: Error Opening BUY Order: 130

    ecco il codice completo che abbiamo scritto. trova l'errore: //±-----------------------------------------------------------------+ //| SpudFrye Method EA v001.mq4 | //| Copyright © 2024, G.Bassi | //±-----------------------------------------------------------------+ #include <stdlib.mqh> #include <stderror.mqh>

    // Dichiarazione delle variabili esterne extern double Lots = 1; // Dimensione del lotto standard

    // Controllo del profitto extern double StopLoss = 100; // Massimo pip disposti a perdere per posizione extern bool UseTrailingStop = true; // Se utilizzare Trailing Stop extern int TrailingStopType = 2; // Tipo di Trailing Stop (1 immediato, 2 attesa) extern double TrailingStop = 25; // Numero di pips per il trailing stop extern bool UseTakeProfit = false; // Se utilizzare Take Profit extern int TakeProfit = 999; // Massimo livello di profitto raggiungibile extern int Slippage = 3; // Slittamento possibile

    // Intestazioni di etichettatura trade string label = "== scegli 15, 30, 60, 240 (4 ore) per timeframe di uscita"; extern int exittimeframe = 30; // Timeframe di uscita

    // Variabili interne double lowlimit = 20; double highlimit = 80; double myStopLoss;
    double lotMM; int MagicNumber; string setup = "";

    // Riprova impostazioni int totalTries = 5; int retryDelay = 1000;

    // Debugging bool Debug=false;

    //±-----------------------------------------------------------------+ //| Funzione di init() | //±-----------------------------------------------------------------+ int init() { MagicNumber = 5000 + Symbol2Val(Symbol()) * 100 + TimeFrame_Const2Val(Period()); setup = "Stoch 5 EA " + Symbol() + "_" + TimeFrame_Val2String(TimeFrame_Const2Val(Period())); return(0); }

    //±-----------------------------------------------------------------+ //| Funzione di deinit() | //±-----------------------------------------------------------------+ int deinit() { // Qui potresti implementare la pulizia delle risorse se necessario return(0); }

    //NormalizeDouble double NormalizePrice(double price) { return(NormalizeDouble(price, Digits)); }

    double GetMinStopLoss(double price, bool isBuy) { double minStopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * Point; if (isBuy) { // Per ordini di acquisto, lo stop loss non può essere inferiore al prezzo corrente più il minStopLevel return(NormalizePrice(price + minStopLevel)); } else { // Per ordini di vendita, lo stop loss non può essere maggiore del prezzo corrente meno il minStopLevel return(NormalizePrice(price - minStopLevel)); } }

    //±-----------------------------------------------------------------+ //| Controlla le posizioni aperte | //±-----------------------------------------------------------------+ int CheckOpenPositions() { int NumBuyTrades = 0, NumSellTrades = 0; for (int i = 0; i < OrdersTotal(); i++) { if (!OrderSelect(i, SELECT_BY_POS, MODE_TRADES) || OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber) continue;

      if (OrderType() == OP_BUY) NumBuyTrades++;
      if (OrderType() == OP_SELL) NumSellTrades++;
    

    } return (NumBuyTrades + NumSellTrades); }

    //±-----------------------------------------------------------------+ //| Funzione start() | //±-----------------------------------------------------------------+ int start() { BeginHandleStopLoss(); if (NewBar()) { HandleOpenPositions(); if (CheckOpenPositions() > 0) { return(0); } lotMM = Lots; if(BuySignal()) { OpenBuyOrder(); return(0); } else if(SellSignal()) { OpenSellOrder(); return(0); } } return(0); }

    //±-----------------------------------------------------------------+ //| Delinea se c’è una nuova barra | //±-----------------------------------------------------------------+ bool NewBar() { static datetime lastBarTime = 0; if (Time[0] != lastBarTime) { lastBarTime = Time[0]; return(true); } else { return(false); } }

    //±-----------------------------------------------------------------+ //| Gestisce il trailing stop per tutte le posizioni | //±-----------------------------------------------------------------+ int BeginHandleStopLoss() { for (int cnt = OrdersTotal() - 1; cnt >= 0; cnt--) { if (!OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES)) continue; if (OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber) continue;

      if (OrderType() == OP_BUY || OrderType() == OP_SELL) {
         if (UseTrailingStop) {
            HandleTrailingStop(OrderType(),OrderTicket(),OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit());
         }
      }
    

    } return(0); }

    //±-----------------------------------------------------------------+ //| Segnale di acquisto tramite analisi dello stocastico | //±-----------------------------------------------------------------+ bool BuySignal() { if (StochOpen("Long")) return(true); return(false);
    }

    //±-----------------------------------------------------------------+ //| Segnale di vendita tramite analisi dello stocastico | //±-----------------------------------------------------------------+ bool SellSignal() { if (StochOpen("Short")) return(true); return(false);
    }

    //±-----------------------------------------------------------------+ //| Apertura di un ordine di acquisto | //±-----------------------------------------------------------------+ void OpenBuyOrder() { double ask = MarketInfo(Symbol(), MODE_ASK); double stopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * Point; double myStopLoss = ask - StopLoss * Point; myStopLoss = (myStopLoss > ask + stopLevel) ? myStopLoss : ask + stopLevel; myStopLoss = NormalizeDouble(myStopLoss, Digits);

    double myTakeProfit = 0;
    if (UseTakeProfit && TakeProfit > 0) {
        myTakeProfit = ask + TakeProfit * Point;
        myTakeProfit = NormalizeDouble(myTakeProfit, Digits);
    }
    
    int ticket = OrderSend(Symbol(), OP_BUY, Lots, ask, Slippage, myStopLoss, myTakeProfit, setup, MagicNumber, 0, clrGreen);
    
    if (ticket < 0) {
        Print("Error Opening BUY Order: ", GetLastError());
    } else {
        if (Debug) Print("BUY Order opened at ", ask);
    }
    

    }

    //±-----------------------------------------------------------------+ //| Apertura di un ordine di vendita | //±-----------------------------------------------------------------+ void OpenSellOrder() { double bid = MarketInfo(Symbol(), MODE_BID); double stopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * Point; double myStopLoss = bid + StopLoss * Point; myStopLoss = (myStopLoss < bid - stopLevel) ? myStopLoss : bid - stopLevel; myStopLoss = NormalizeDouble(myStopLoss, Digits);

    double myTakeProfit = 0;
    if (UseTakeProfit && TakeProfit > 0) {
        myTakeProfit = bid - TakeProfit * Point;
        myTakeProfit = NormalizeDouble(myTakeProfit, Digits);
    }
    
    int ticket = OrderSend(Symbol(), OP_SELL, Lots, bid, Slippage, myStopLoss, myTakeProfit, setup, MagicNumber, 0, clrRed);
    
    if (ticket < 0) {
        Print("Error Opening SELL Order: ", GetLastError());
    } else {
        if (Debug) Print("SELL Order opened at ", bid);
    }
    

    }

    //±-----------------------------------------------------------------+ //| Analisi Stocastica per i segnali di apertura ordini | //±-----------------------------------------------------------------+ bool StochOpen(string signal) { double main = iStochastic(NULL, 0, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 1); double main_last = iStochastic(NULL, 0, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 2);

    if (signal == "Long" && main > main_last && main_last < lowlimit) { return true; } if (signal == "Short" && main < main_last && main_last > highlimit) { return true; } return false; } //±-----------------------------------------------------------------+ //| Gestione delle posizioni aperte | //±-----------------------------------------------------------------+ int HandleOpenPositions() { for (int cnt = OrdersTotal() - 1; cnt >= 0; cnt--) { if (!OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES)) continue; if (OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber) continue;

      if (OrderType() == OP_BUY) {
          // Qui potrebbe andare la logica di uscita per il BUY se necessaria
      } else if (OrderType() == OP_SELL) {
          // E qui quella di uscita per il SELL se necessaria
      }
    

    } return(0); }

    //±-----------------------------------------------------------------+ //| Trailing stop effettivo per una posizione | //±-----------------------------------------------------------------+ void HandleTrailingStop(int tradeType, int ticket, double openPrice, double currentStop, double currentTP) { double point = MarketInfo(Symbol(), MODE_POINT); double newStop;

    if (tradeType == OP_BUY) { double buyTrailStopLevel = openPrice + TrailingStop * point; if (Bid >= buyTrailStopLevel) { newStop = Bid - TrailingStop * point; newStop = NormalizeDouble(newStop, Digits); if (newStop != currentStop) { OrderModify(ticket, openPrice, newStop, currentTP, 0, clrNONE); if (Debug) Print("Modificato il Trailing Stop BUY per il ticket ", ticket); } } } else if (tradeType == OP_SELL) { double sellTrailStopLevel = openPrice - TrailingStop * point; if (Ask <= sellTrailStopLevel) { newStop = Ask + TrailingStop * point; newStop = NormalizeDouble(newStop, Digits); if (newStop != currentStop) { OrderModify(ticket, openPrice, newStop, currentTP, 0, clrNONE); if (Debug) Print("Modificato il Trailing Stop SELL per il ticket ", ticket); } } } }

    //±-----------------------------------------------------------------+ //| Verifica che lo stop loss sia valido e lo normalizza | //±-----------------------------------------------------------------+ double ValidStopLoss(int tradeType, double proposedStop) { double minStopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * MarketInfo(Symbol(), MODE_POINT);

    // Ajusta lo stop loss proposto a seconda se è BUY o SELL if (tradeType == OP_BUY && proposedStop < Ask - minStopLevel) { return (Ask - minStopLevel); } else if (tradeType == OP_SELL && proposedStop > Bid + minStopLevel) { return (Bid + minStopLevel); } return(proposedStop); } //±-----------------------------------------------------------------+ //| Indicatori ausiliari | //±-----------------------------------------------------------------+ int TimeFrame_Const2Val(int Constant) { switch(Constant) { case 1:
    return(1); case 5:
    return(2); case 15: return(3); case 30: return(4); case 60: return(5); case 240: return(6); case 1440: return(7); case 10080: return(8); case 43200: return(9); default: return(-1); // Valore di default se nessun caso è stato abbinato } } //+------------------------------------------------------------------+ //| Time frame string appropriation function | //+------------------------------------------------------------------+ string TimeFrame_Val2String(int Value ) { switch(Value) { case 1:
    return("PERIOD_M1"); case 2:
    return("PERIOD_M5"); case 3: return("PERIOD_M15"); case 4: return("PERIOD_M30"); case 5: return("PERIOD_H1"); case 6: return("PERIOD_H4"); case 7: return("PERIOD_D1"); case 8: return("PERIOD_W1"); case 9: return("PERIOD_MN1"); default: return("undefined " + Value); } } int Symbol2Val(string symbol) { string mySymbol = StringSubstr(symbol,0,6); if(mySymbol=="AUDCAD") return(1); if(mySymbol=="AUDJPY") return(2); if(mySymbol=="AUDNZD") return(3); if(mySymbol=="AUDUSD") return(4); if(mySymbol=="CHFJPY") return(5); if(mySymbol=="EURAUD") return(6); if(mySymbol=="EURCAD") return(7); if(mySymbol=="EURCHF") return(8); if(mySymbol=="EURGBP") return(9); if(mySymbol=="EURJPY") return(10); if(mySymbol=="EURUSD") return(11); if(mySymbol=="GBPCHF") return(12); if(mySymbol=="GBPJPY") return(13); if(mySymbol=="GBPUSD") return(14); if(mySymbol=="NZDUSD") return(15); if(mySymbol=="USDCAD") return(16); if(mySymbol=="USDCHF") return(17); if(mySymbol=="USDJPY") return(18); return(19); }

  30. Assistant

    Il problema con l'errore 130 indica che il livello di stop stabilito è troppo vicino al prezzo di mercato attuale, violando i requisiti fissati dal broker. Può essere necessario un approccio più accurato per garantire che il livello di stop sia valido.

    Dato che hai incluso le funzioni validate ValidStopLoss, NormalizePrice e GetMinStopLoss, ma non le stai chiamando nel codice attuale, ti consiglio di modificarlo per usarle correttamente. Ricorda, però, che le funzioni NormalizePrice e GetMinStopLoss non sono più necessarie se si usa la funzione ValidStopLoss correttamente, quindi procederò a eliminare quelle funzioni e ad usare ValidStopLoss nel codice delle funzioni OpenBuyOrder e OpenSellOrder.

    Ecco il tuo codice modificato solo per le funzioni OpenBuyOrder e OpenSellOrder per utilizzare correttamente ValidStopLoss:

    //±-----------------------------------------------------------------+
    //| Apertura di un ordine di acquisto                                |
    //±-----------------------------------------------------------------+
    void OpenBuyOrder() {
        double ask = MarketInfo(Symbol(), MODE_ASK);
        double myStopLoss = 0;
        
        if (StopLoss > 0) {
            myStopLoss = ask - StopLoss * Point;
            myStopLoss = ValidStopLoss(OP_BUY, myStopLoss);
        }
        
        double myTakeProfit = 0;
        if (UseTakeProfit && TakeProfit > 0) {
            myTakeProfit = ask + TakeProfit * Point;
            myTakeProfit = ValidStopLoss(OP_BUY, myTakeProfit);  // questa potrebbe non essere necessaria per il TP
        }
        
        myStopLoss = NormalizeDouble(myStopLoss, Digits);
        myTakeProfit = NormalizeDouble(myTakeProfit, Digits);
        
        int ticket = OrderSend(Symbol(), OP_BUY, Lots, ask, Slippage, myStopLoss, myTakeProfit, 
                               setup, MagicNumber, 0, clrGreen);
        
        if (ticket < 0) {
            Print("Error Opening BUY Order: ", GetLastError());
        } else {
            if (Debug) Print("BUY Order opened at ", ask, " SL: ", myStopLoss, " TP: ", myTakeProfit);
        }
    }
    
    //±-----------------------------------------------------------------+
    //| Apertura di un ordine di vendita                                 |
    //±-----------------------------------------------------------------+
    void OpenSellOrder() {
        double bid = MarketInfo(Symbol(), MODE_BID);
        double myStopLoss = 0;
       
        if (StopLoss > 0) {
            myStopLoss = bid + StopLoss * Point;
            myStopLoss = ValidStopLoss(OP_SELL, myStopLoss);
        }
    
        double myTakeProfit = 0;
        if (UseTakeProfit && TakeProfit > 0) {
            myTakeProfit = bid - TakeProfit * Point;
            myTakeProfit = ValidStopLoss(OP_SELL, myTakeProfit);  // questa potrebbe non essere necessaria per il TP
        }
       
        myStopLoss = NormalizeDouble(myStopLoss, Digits);
        myTakeProfit = NormalizeDouble(myTakeProfit, Digits);
        
        int ticket = OrderSend(Symbol(), OP_SELL, Lots, bid, Slippage, myStopLoss, myTakeProfit, 
                               setup, MagicNumber, 0, clrRed);
        
        if (ticket < 0) {
            Print("Error Opening SELL Order: ", GetLastError());
        } else {
            if (Debug) Print("SELL Order opened at ", bid, " SL: ", myStopLoss, " TP: ", myTakeProfit);
        }
    }
    

    La funzione ValidStopLoss è utilizzata per assicurare che il livello di stop sia maggiore del livello di stop minimo per le operazioni di acquisto e minore del livello di stop minimo per le operazioni di vendita.

    Dopo aver apportato queste modifiche, compila nuovamente il codice nella MetaEditor di MT4 e testalo con lo Strategy Tester per vedere se il problema è stato risolto.

  31. User

    sempre lo stesso errore. c'è un errore nel codice, il broker non ha preferenze. l'errore compare anche inserendo uno SL e un TP a 500 pips

  32. Assistant

    Se l'errore 130 persiste anche con uno stop loss e un take profit impostati a un valore molto alto come 500 pips, allora possiamo sospettare della presenza di un altro problema.

    Un'ulteriore verifica potrebbe essere quella di assicurarsi che il valore di Point sia calcolato correttamente e che siano presi in considerazione i requisiti della coppia di valute. Ad esempio, EURJPY e coppie con lo JPY in generale hanno una diversa definizione di pip rispetto alle altre coppie come EURUSD.

    Per chiarire, un pip per la maggior parte delle coppie è 0.0001, mentre per le coppie JPY (come EURJPY), un pip è 0.01. Il valore di Point in MQL4 ritorna il valore minimo di variazione del prezzo per una determinata coppia di valute e dovrebbe essere utilizzato per convertire i pips in valori di prezzo.

    Per essere conservativi, possiamo anche aggiungere un buffer aggiuntivo al livello di stop. Ecco le funzioni OpenBuyOrder e OpenSellOrder modificate per includere un buffer aggiuntivo:

    void OpenBuyOrder() {
        double ask = MarketInfo(Symbol(), MODE_ASK);
        double slippagePoints = Slippage * Point;
        double stopBuffer = 2 * MarketInfo(Symbol(), MODE_STOPLEVEL) * Point; // Buffer di sicurezza aggiuntivo
        double myStopLoss = ask - StopLoss * Point - stopBuffer;
    
        myStopLoss = NormalizeDouble(myStopLoss, Digits);
    
        double myTakeProfit = 0;
        if (UseTakeProfit && TakeProfit > 0) {
            myTakeProfit = ask + TakeProfit * Point;
            myTakeProfit = NormalizeDouble(myTakeProfit, Digits);
        }
        
        int ticket = OrderSend(Symbol(), OP_BUY, Lots, NormalizeDouble(ask, Digits), slippagePoints, myStopLoss, myTakeProfit, setup, MagicNumber, 0, clrGreen);
        if (ticket < 0) {
            Print("Error Opening BUY Order: ", GetLastError());
        } 
    }
    
    void OpenSellOrder() {
        double bid = MarketInfo(Symbol(), MODE_BID);
        double slippagePoints = Slippage * Point;
        double stopBuffer = 2 * MarketInfo(Symbol(), MODE_STOPLEVEL) * Point; // Buffer di sicurezza aggiuntivo
        double myStopLoss = bid + StopLoss * Point + stopBuffer;
    
        myStopLoss = NormalizeDouble(myStopLoss, Digits);
    
        double myTakeProfit = 0;
        if (UseTakeProfit && TakeProfit > 0) {
            myTakeProfit = bid - TakeProfit * Point;
            myTakeProfit = NormalizeDouble(myTakeProfit, Digits);
        }
        
        int ticket = OrderSend(Symbol(), OP_SELL, Lots, NormalizeDouble(bid, Digits), slippagePoints, myStopLoss, myTakeProfit, setup, MagicNumber, 0, clrRed);
        if (ticket < 0) {
            Print("Error Opening SELL Order: ", GetLastError());
        } 
    }
    

    In questo codice, ho aggiunto:

    • Un buffer stopBuffer che è il doppio del livello minimo di stop del broker (MODE_STOPLEVEL) per aggiungere un margine aggiuntivo.
    • Utilizzo di NormalizeDouble per assicurare che sia l'ask per il BUY, sia il bid per il SELL siano normalizzati a seconda della precisione del simbolo (Digits).

    Compila di nuovo e testa questo codice nell'ambiente di test. Se l'errore persiste, potrebbe essere utile esaminare altri possibili problemi con la configurazione del server o contattare il supporto tecnico del broker per ulteriori indagini.

  33. User

    confermi che questa è la logica per aprire gli ordini: bool StochOpen(string signal) { double main = iStochastic(NULL, 0, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1); double main_last = iStochastic(NULL, 0, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 2);

    if (signal == "Long" && main > main_last && main_last < lowlimit) { return true; } if (signal == "Short" && main < main_last && main_last > highlimit) { return true; } return false;

  34. Assistant

    La logica per aprire gli ordini tramite la funzione StochOpen che hai fornito si basa sull'indicatore stocastico e prevede i seguenti criteri:

    1. Per un segnale di acquisto ("Long"):

      • Lo stocastico principale corrente (main) deve essere maggiore di quello precedente (main_last).
      • Lo stocastico principale precedente (main_last) deve essere inferiore al limite inferiore (lowlimit), che è un valore soglia che definisci come il punto di ingresso per un trend rialzista.
    2. Per un segnale di vendita ("Short"):

      • Lo stocastico principale corrente (main) deve essere inferiore a quello precedente (main_last).
      • Lo stocastico principale precedente (main_last) deve essere superiore al limite superiore (highlimit), che è un valore soglia che definisci come il punto di ingresso per un trend ribassista.

    Strutturalmente, la logica sembra essere corretta per un approccio basato sull'indicatore stocastico. Tuttavia, assicurati di notare i seguenti punti chiave:

    • I valori di lowlimit e highlimit devono essere definiti in modo appropriato in base alla tua strategia e alla sensibilità desiderata del segnale.
    • Verifica che il primo parametro passato alla funzione iStochastic sia corretto. Attualmente, è impostato su NULL, che userà le informazioni del simbolo e del timeframe correnti. Se desideri calcolare lo stocastico per un timeframe diverso da quello corrente, dovresti specificare il relativo identificatore (ad esempio, PERIOD_M15, PERIOD_H1, ecc.).
    • Assicurati che l'indice di MODE_MAIN che stai usando nell'indicatore stocastico (1 per l'ultimo valore e 2 per il penultimo valore) sia in linea con la tua logica. In MQL4, l'indice 0 rappresenta il valore corrente più recente, l'indice 1 il valore della barra precedente e così via.

    La tua implementazione attuale sembra mirare a identificare il momento in cui lo stocastico fa un'inversione al rialzo al di sotto di un certo valore soglia per entrare lungo (buy), o quando fa un'inversione al ribasso al di sopra di un certo valore soglia per entrare corto (sell), che è un'interpretazione ragionevole per un segnale di trading.

  35. User

    L'EA originale aveva regole diverse bool stochOpen(string signal) { bool stochbool=false; double main_15 = iStochastic(NULL,PERIOD_M15,14,3,3,MODE_SMA,0,MODE_MAIN,1); double main_15last = iStochastic(NULL,PERIOD_M15,14,3,3,MODE_SMA,0,MODE_MAIN,2); double main_30 = iStochastic(NULL,PERIOD_M30,14,3,3,MODE_SMA,0,MODE_MAIN,1); double main_30last = iStochastic(NULL,PERIOD_M30,14,3,3,MODE_SMA,0,MODE_MAIN,2); double main_1H = iStochastic(NULL,PERIOD_H1,14,3,3,MODE_SMA,0,MODE_MAIN,1); double main_1Hlast = iStochastic(NULL,PERIOD_H1,14,3,3,MODE_SMA,0,MODE_MAIN,2); double main_4H = iStochastic(NULL,PERIOD_H4,14,3,3,MODE_SMA,0,MODE_MAIN,1); double main_4Hlast = iStochastic(NULL,PERIOD_H4,14,3,3,MODE_SMA,0,MODE_MAIN,2); //---------------------- double main_152 = iStochastic(NULL,PERIOD_M15,14,3,3,MODE_SMA,0,MODE_MAIN,1); double main_152last = iStochastic(NULL,PERIOD_M15,14,3,3,MODE_SMA,0,MODE_MAIN,2);
    double main_302 = iStochastic(NULL,PERIOD_M30,14,3,3,MODE_SMA,0,MODE_MAIN,1); double main_302last = iStochastic(NULL,PERIOD_M30,14,3,3,MODE_SMA,0,MODE_MAIN,2); double main_1H2 = iStochastic(NULL,PERIOD_H1,14,3,3,MODE_SMA,0,MODE_MAIN,1); double main_1H2last = iStochastic(NULL,PERIOD_H1,14,3,3,MODE_SMA,0,MODE_MAIN,2); double main_4H2 = iStochastic(NULL,PERIOD_H4,14,3,3,MODE_SMA,0,MODE_MAIN,1); double main_4H2last = iStochastic(NULL,PERIOD_H4,14,3,3,MODE_SMA,0,MODE_MAIN,2);

    if (signal=="Short" && (main_15 < main_15last) && (main_15last > highlimit) && (main_15 < highlimit) && (main_30 < main_15last) && (main_30last > highlimit) && (main_30 < highlimit) && (main_1H < main_15last) && (main_1Hlast > highlimit) && (main_1H < highlimit) && (main_4H < main_15last) && (main_4Hlast > highlimit) && (main_4H < highlimit) && (main_152 < main_15last) && (main_152last > highlimit) && (main_152 < highlimit) && (main_302 < main_15last) && (main_302last > highlimit) && (main_302 < highlimit) && (main_1H2 < main_15last) && (main_1H2last > highlimit) && (main_1H2 < highlimit) && (main_4H2 < main_15last) && (main_4H2last > highlimit) && (main_4H2 < highlimit)) stochbool=true; if (signal=="Long" && (main_15 > main_15last) && (main_15last < lowlimit) && (main_15 > lowlimit) && (main_30 > main_15last) && (main_30last < lowlimit) && (main_30 > lowlimit) && (main_1H > main_15last) && (main_1Hlast < lowlimit) && (main_1H > lowlimit) && (main_4H > main_15last) && (main_4Hlast < lowlimit) && (main_4H > lowlimit) && (main_152 > main_15last) && (main_152last < lowlimit) && (main_152 > lowlimit) && (main_302 > main_15last) && (main_302last < lowlimit) && (main_302 > lowlimit) && (main_1H2 > main_15last) && (main_1H2last < lowlimit) && (main_1H2 > lowlimit) && (main_4H2 > main_15last) && (main_4H2last < lowlimit) && (main_4H2 > lowlimit)) stochbool=true; return(stochbool); }

    come puoi notare usa 4 timeframes.

  36. Assistant

    Grazie per la precisazione. La funzione stochOpen nell'EA originale usa dei controlli su quattro timeframe diversi (M15, M30, H1, H4) per determinare quando aprire un ordine lungo (Long) o corto (Short) basato sull'indicatore stocastico.

    La logica che hai fornito verifica che:

    • Per un segnale "Short" (vendita), lo stocastico principale deve diminuire (il valore corrente è inferiore a quello precedente) e il valore precedente deve essere superiore al highlimit su tutti e quattro i timeframe. Inoltre, c'è un controllo ridondante: viene confrontato nuovamente lo stocastico corrente di ogni timeframe rispetto al valore precedente dello stesso timeframe. Questo sembra un errore, in quanto le coppie di variabili main_X e main_Xlast sono ricreate senza una chiara ragione; queste variabili sembrano superflue e potrebbero essere rimosse.
    • Per un segnale "Long" (acquisto), invece, lo stocastico principale deve essere in aumento (il valore corrente è maggiore del precedente) e il valore precedente deve essere inferiore al lowlimit su tutti e quattro i timeframe.

    Le condizioni per entrambi i segnali devono essere tutte vere affinché venga restituito un segnale true.

    Tuttavia, ci sono chiaramente delle ripetizioni e delle variabili superflue nel tuo ultimo snippet di codice. Sembrerebbe che il codice sia stato copiato erroneamente o che siano stati commessi degli errori di duplicazione durante la scrittura del codice. Le coppie di variabili "2" (main_152, main_152last, main_302, ecc.) non sono necessarie e non contribuiscono alla logica del segnale. Quindi, puoi rimuoverle.

    Ecco la funzione stochOpen migliorata senza ridondanza:

    bool stochOpen(string signal) { 
       bool stochbool = false;
       double main_15 = iStochastic(NULL, PERIOD_M15, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
       double main_15last = iStochastic(NULL, PERIOD_M15, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 2);
       double main_30 = iStochastic(NULL, PERIOD_M30, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
       double main_30last = iStochastic(NULL, PERIOD_M30, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 2);
       double main_1H = iStochastic(NULL, PERIOD_H1, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
       double main_1Hlast = iStochastic(NULL, PERIOD_H1, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 2);
       double main_4H = iStochastic(NULL, PERIOD_H4, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
       double main_4Hlast = iStochastic(NULL, PERIOD_H4, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 2);
       
       if (signal == "Short" && 
           (main_15 < main_15last) && (main_15last > highlimit) &&
           (main_30 < main_30last) && (main_30last > highlimit) &&
           (main_1H < main_1Hlast) && (main_1Hlast > highlimit) &&
           (main_4H < main_4Hlast) && (main_4Hlast > highlimit)) {
           stochbool = true;
       }
       
       if (signal == "Long" &&
           (main_15 > main_15last) && (main_15last < lowlimit) &&
           (main_30 > main_30last) && (main_30last < lowlimit) &&
           (main_1H > main_1Hlast) && (main_1Hlast < lowlimit) &&
           (main_4H > main_4Hlast) && (main_4Hlast < lowlimit)) {
           stochbool = true;
       }
       
       return(stochbool);
    }
    

    Assicurati che i valori di lowlimit e highlimit siano correttamente impostati secondo la strategia che desideri seguire. Dopo aver corretto la funzione, dovresti essere in grado di utilizzare stochOpen nel tuo EA per generare segnali di trading basati sull'indicatore stocastico attraverso vari timeframe.

  37. User

    questa era la strategia originale da cui è stato ispirato l'EA 1.Always wait for the 4H chart to lead our entry. 2. Long trades are entered when all 4 time frame stochastics are moving upwards and the solid lines are all above or at 20 (lowlimit). 3. Short trades are entered when all 4 time frame stochastics are moving downwards and the solid lines are all below or at 80(highlimit). corrisponde?

  38. Assistant

    Grazie per aver condiviso la strategia di trading originale. Basandomi sulla descrizione fornita, la logica originale richiede che per aprire una posizione:

    • In un trade Long (acquisto): Tutti e quattro gli indicatori stocastici dei diversi timeframe (M15, M30, H1, H4) devono essere in movimento verso l'alto e i valori solidi delle linee dello stocastico devono essere tutti sopra o al livello di 20 (lowlimit).
    • In un trade Short (vendita): Tutti e quattro gli indicatori stocastici dei diversi timeframe (M15, M30, H1, H4) devono essere in movimento verso il basso e i valori solidi delle linee dello stocastico devono essere tutti sotto o al livello di 80 (highlimit).

    La funzione stochOpen che hai condiviso nel precedente messaggio sembra adeguarsi a questa logica, con l'eccezione della verifica del leading timeframe (H4). È importante assicurarsi che il 4H stocastico effettivamente guidi l'ingresso, come specificato nel punto 1. Per includere questo controllo esplicitamente e allineare la funzione con la strategia, occorrerebbe aggiungere una condizione per garantire che il 4H stocastico sia in linea con i segnali degli altri timeframe.

    Ecco come potreste implementare questa logica nella funzione stochOpen:

    bool stochOpen(string signal) {
       double main_15 = iStochastic(NULL, PERIOD_M15, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
       double main_15last = iStochastic(NULL, PERIOD_M15, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 2);
       double main_30 = iStochastic(NULL, PERIOD_M30, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
       double main_30last = iStochastic(NULL, PERIOD_M30, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 2);
       double main_1H = iStochastic(NULL, PERIOD_H1, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
       double main_1Hlast = iStochastic(NULL, PERIOD_H1, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 2);
       double main_4H = iStochastic(NULL, PERIOD_H4, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
       double main_4Hlast = iStochastic(NULL, PERIOD_H4, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 2);
       
       if (signal == "Long" &&
           main_4H > main_4Hlast && main_4H > lowlimit &&
           main_15 > main_15last && main_15 > lowlimit &&
           main_30 > main_30last && main_30 > lowlimit &&
           main_1H > main_1Hlast && main_1H > lowlimit) {
           return true;
       }
       
       if (signal == "Short" &&
           main_4H < main_4Hlast && main_4H < highlimit &&
           main_15 < main_15last && main_15 < highlimit &&
           main_30 < main_30last && main_30 < highlimit &&
           main_1H < main_1Hlast && main_1H < highlimit) {
           return true;
       }
       
       return false;
    }
    

    In questo modo, la prima condizione è che la linea principale dello stocastico 4H sia maggiore o minore dell'ultima (a seconda che si tratti di un segnale Long o Short) prima di verificare le condizioni degli altri timeframe. Questa implementazione si assicura che il segnale di trading sia guidato dal timeframe 4H, in conformità con la strategia descritta.

  39. User

    c'è qualcosa che non va, apre toppi trades. deve aprire un trade solamente quando lo stocastico 4h supera da sotto il lowlimit ecc

  40. Assistant

    Il problema potrebbe essere che la tua funzione stochOpen sta aprendo posizioni non appena trova che la condizione di stocastico è soddisfatta, senza controllare se è stata superata recentemente (crossed-over).

    Se vuoi aprire un trade solo quando lo stocastico del 4H attraversa il lowlimit o il highlimit per la prima volta, dovresti verificare il crossing oltre questi limiti e non solo che lo stocastico corrente sia superiore o inferiore a tali limiti.

    Modifichiamo la funzione stochOpen per aprire un trade solo nel momento in cui viene effettuato il crossover di questi limiti:

    bool stochOpen(string signal) {
       // Ottieni i valori attuali dello stocastico per tutti i timeframe
       double main_15 = iStochastic(NULL, PERIOD_M15, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);
       double main_30 = iStochastic(NULL, PERIOD_M30, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);
       double main_1H = iStochastic(NULL, PERIOD_H1, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);
       double main_4H = iStochastic(NULL, PERIOD_H4, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);
       
       // Ottieni i valori dello stocastico della barra precedente per il 4H 
       double main_4Hlast = iStochastic(NULL, PERIOD_H4, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
       
       if (signal == "Long" &&
           main_4Hlast < lowlimit && main_4H > lowlimit && // Verifica il crossover da sotto
           main_15 > lowlimit &&
           main_30 > lowlimit &&
           main_1H > lowlimit) {
           return true;
       }
       
       if (signal == "Short" &&
           main_4Hlast > highlimit && main_4H < highlimit && // Verifica il crossover da sopra
           main_15 < highlimit &&
           main_30 < highlimit &&
           main_1H < highlimit) {
           return true;
       }
       
       return false;
    }
    

    In questa versione modificata, la funzione stochOpen per il segnale "Long" verifica che lo stocastico sul timeframe 4H sia passato dal sotto al sopra del lowlimit e viceversa per il segnale "Short", dal sopra al sotto del highlimit.

    Inoltre, potrebbe essere necessario aggiungere un controllo per garantire che il trade non sia già aperto sul segnale attuale. Presumo che tu possa già avere una logica che impedisca di aprire più trades contemporaneamente sullo stesso segnale, ma se non l'hai, potresti dover implementare un controllo che tenga traccia degli stati di trading.

    Assicurati anche di testare queste modifiche in un ambiente sicuro (ad esempio su un account demo) prima di utilizzarle in un ambiente di trading dal vivo.

  41. User

    il problema è un po' migliorato ma non molto. continua ad aprire molti trade sopo il primo 4h segnale. deve aprirne solamente 1.

  42. Assistant

    Per aprire un solo trade in seguito al primo segnale fornito dallo stocastico 4H, dovresti implementare un controllo che tiene traccia se un trade è stato già aperto e agisce di conseguenza. Questo si ottiene di solito aggiungendo una variabile di stato che mantiene se un trade a seguito del segnale corrente è stato già inserito.

    Qui c'è un esempio di come puoi aggiungere un controllo per assicurarti di aprire solo un trade per segnale:

    1. Aggiungere una variabile di stato globale nel tuo EA (fuori da qualunque funzione):
    bool tradeOpened = false; // Variabile globale per tener traccia se un trade è stato aperto
    
    1. Aggiornare la variabile tradeOpened quando apri un trade:
    void OpenBuyOrder() {
        // Se un trade è stato già aperto, non proseguire
        if(tradeOpened) return;
    
        // ... (il resto della logica per aprire un trade)
    
        // Se il trade viene effettivamente aperto:
        if(ticket > 0) {
            tradeOpened = true; // Imposta tradeOpened a true per evitare altri trade
        }
    }
    
    void OpenSellOrder() {
        // Se un trade è stato già aperto, non proseguire
        if(tradeOpened) return;
    
        // ... (il resto della logica per aprire un trade)
    
        // Se il trade viene effettivamente aperto:
        if(ticket > 0) {
            tradeOpened = true; // Imposta tradeOpened a true per evitare altri trade
        }
    }
    
    1. Reset della variabile tradeOpened quando non ci sono più posizioni aperte o quando decidi di chiudere le posizioni.

    Per resettare la variabile tradeOpened, dovresti farlo in base alla logica specifica che determina quando è il momento giusto per consentire un nuovo trade. Questo potrebbe essere, ad esempio, quando tutte le posizioni aperte vengono chiuse.

    Ecco un esempio di come puoi resettare la variabile tradeOpened quando non ci sono posizioni aperte:

    void HandleOpenPositions() {
       // Tieni traccia del numero totale di posizioni aperte
       int totalOpenPositions = CheckOpenPositions();
    
       if(totalOpenPositions == 0) {
           tradeOpened = false; // Prepara per un nuovo trade se tutte le posizioni sono state chiuse
       }
    
       // ... (il resto della tua logica per gestire posizioni aperte)
    }
    

    Ricorda che questo è solo un esempio di base e dovrai adattare la logica al tuo specifico stile di trading e alla struttura del tuo EA. Inoltre, potresti aver bisogno di controllare non solo se qualsiasi trade è stato aperto, ma anche se un trade per una specifica strategia è stato aperto. Ciò richiederebbe di tenere traccia degli stati dei trade per ogni strategia o condizione.

  43. User

    questo è il codice completo. scrivi le parti da cambiare per effettuare 1 solo trade per segnale //±-----------------------------------------------------------------+ //| SpudFrye Method EA v001.mq4 | //| Copyright © 2024, G.Bassi | //±-----------------------------------------------------------------+ #include <stdlib.mqh> #include <stderror.mqh>

    // Dichiarazione delle variabili esterne extern double Lots = 1; // Dimensione del lotto standard

    // Controllo del profitto extern double StopLoss = 50; // Massimo pip disposti a perdere per posizione extern bool UseTrailingStop = true; // Se utilizzare Trailing Stop extern int TrailingStopType = 2; // Tipo di Trailing Stop (1 immediato, 2 attesa) extern double TrailingStop = 25; // Numero di pips per il trailing stop extern bool UseTakeProfit = true; // Se utilizzare Take Profit extern int TakeProfit = 100; // Massimo livello di profitto raggiungibile extern int Slippage = 3; // Slittamento possibile

    // Intestazioni di etichettatura trade string label = "== scegli 15, 30, 60, 240 (4 ore) per timeframe di uscita"; extern int exittimeframe = 30; // Timeframe di uscita

    // Variabili interne double lowlimit = 20; double highlimit = 80; double myStopLoss;
    double lotMM; int MagicNumber; string setup = "";

    // Riprova impostazioni int totalTries = 5; int retryDelay = 1000;

    // Debugging bool Debug=false;

    //±-----------------------------------------------------------------+ //| Funzione di init() | //±-----------------------------------------------------------------+ int init() { MagicNumber = 5000 + Symbol2Val(Symbol()) * 100 + TimeFrame_Const2Val(Period()); setup = "Stoch 5 EA " + Symbol() + "_" + TimeFrame_Val2String(TimeFrame_Const2Val(Period())); return(0); }

    //±-----------------------------------------------------------------+ //| Funzione di deinit() | //±-----------------------------------------------------------------+ int deinit() { // Qui potresti implementare la pulizia delle risorse se necessario return(0); }

    //NormalizeDouble double NormalizePrice(double price) { return(NormalizeDouble(price, Digits)); }

    double GetMinStopLoss(double price, bool isBuy) { double minStopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * Point; if (isBuy) { // Per ordini di acquisto, lo stop loss non può essere inferiore al prezzo corrente più il minStopLevel return(NormalizePrice(price + minStopLevel)); } else { // Per ordini di vendita, lo stop loss non può essere maggiore del prezzo corrente meno il minStopLevel return(NormalizePrice(price - minStopLevel)); } }

    //±-----------------------------------------------------------------+ //| Controlla le posizioni aperte | //±-----------------------------------------------------------------+ int CheckOpenPositions() { int NumBuyTrades = 0, NumSellTrades = 0; for (int i = 0; i < OrdersTotal(); i++) { if (!OrderSelect(i, SELECT_BY_POS, MODE_TRADES) || OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber) continue;

      if (OrderType() == OP_BUY) NumBuyTrades++;
      if (OrderType() == OP_SELL) NumSellTrades++;
    

    } return (NumBuyTrades + NumSellTrades); }

    //±-----------------------------------------------------------------+ //| Funzione start() | //±-----------------------------------------------------------------+ int start() { BeginHandleStopLoss(); if (NewBar()) { HandleOpenPositions(); if (CheckOpenPositions() > 0) { return(0); } lotMM = Lots; if(BuySignal()) { OpenBuyOrder(); return(0); } else if(SellSignal()) { OpenSellOrder(); return(0); } } return(0); }

    //±-----------------------------------------------------------------+ //| Delinea se c’è una nuova barra | //±-----------------------------------------------------------------+ bool NewBar() { static datetime lastBarTime = 0; if (Time[0] != lastBarTime) { lastBarTime = Time[0]; return(true); } else { return(false); } }

    //±-----------------------------------------------------------------+ //| Gestisce il trailing stop per tutte le posizioni | //±-----------------------------------------------------------------+ int BeginHandleStopLoss() { for (int cnt = OrdersTotal() - 1; cnt >= 0; cnt--) { if (!OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES)) continue; if (OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber) continue;

      if (OrderType() == OP_BUY || OrderType() == OP_SELL) {
         if (UseTrailingStop) {
            HandleTrailingStop(OrderType(),OrderTicket(),OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit());
         }
      }
    

    } return(0); }

    //±-----------------------------------------------------------------+ //| Segnale di acquisto tramite analisi dello stocastico | //±-----------------------------------------------------------------+ bool BuySignal() { if (StochOpen("Long")) return(true); return(false);
    }

    //±-----------------------------------------------------------------+ //| Segnale di vendita tramite analisi dello stocastico | //±-----------------------------------------------------------------+ bool SellSignal() { if (StochOpen("Short")) return(true); return(false);
    }

    //±-----------------------------------------------------------------+ //| Apertura di un ordine di acquisto | //±-----------------------------------------------------------------+ void OpenBuyOrder() { double ask = MarketInfo(Symbol(), MODE_ASK); double slippagePoints = Slippage * Point; double stopBuffer = 2 * MarketInfo(Symbol(), MODE_STOPLEVEL) * Point; // Buffer di sicurezza aggiuntivo double myStopLoss = ask - StopLoss * Point - stopBuffer;

    myStopLoss = NormalizeDouble(myStopLoss, Digits);
    
    double myTakeProfit = 0;
    if (UseTakeProfit && TakeProfit > 0) {
        myTakeProfit = ask + TakeProfit * Point;
        myTakeProfit = NormalizeDouble(myTakeProfit, Digits);
    }
    
    int ticket = OrderSend(Symbol(), OP_BUY, Lots, NormalizeDouble(ask, Digits), slippagePoints, myStopLoss, myTakeProfit, setup, MagicNumber, 0, clrGreen);
    if (ticket < 0) {
        Print("Error Opening BUY Order: ", GetLastError());
    } 
    

    }

    void OpenSellOrder() { double bid = MarketInfo(Symbol(), MODE_BID); double slippagePoints = Slippage * Point; double stopBuffer = 2 * MarketInfo(Symbol(), MODE_STOPLEVEL) * Point; // Buffer di sicurezza aggiuntivo double myStopLoss = bid + StopLoss * Point + stopBuffer;

    myStopLoss = NormalizeDouble(myStopLoss, Digits);
    
    double myTakeProfit = 0;
    if (UseTakeProfit && TakeProfit > 0) {
        myTakeProfit = bid - TakeProfit * Point;
        myTakeProfit = NormalizeDouble(myTakeProfit, Digits);
    }
    
    int ticket = OrderSend(Symbol(), OP_SELL, Lots, NormalizeDouble(bid, Digits), slippagePoints, myStopLoss, myTakeProfit, setup, MagicNumber, 0, clrRed);
    if (ticket < 0) {
        Print("Error Opening SELL Order: ", GetLastError());
    } 
    

    }

    //±-----------------------------------------------------------------+ //| Analisi Stocastica per i segnali di apertura ordini | //±-----------------------------------------------------------------+ bool StochOpen(string signal) { double main_15 = iStochastic(NULL, PERIOD_M15, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0); double main_30 = iStochastic(NULL, PERIOD_M30, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0); double main_1H = iStochastic(NULL, PERIOD_H1, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0); double main_4H = iStochastic(NULL, PERIOD_H4, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);

    // Ottieni i valori dello stocastico della barra precedente per il 4H double main_4Hlast = iStochastic(NULL, PERIOD_H4, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);

    if (signal == "Long" && main_4Hlast < lowlimit && main_4H > lowlimit && // Verifica il crossover da sotto main_15 > lowlimit && main_30 > lowlimit && main_1H > lowlimit) { return true; }

    if (signal == "Short" && main_4Hlast > highlimit && main_4H < highlimit && // Verifica il crossover da sopra main_15 < highlimit && main_30 < highlimit && main_1H < highlimit) { return true; }

    return false; } //±-----------------------------------------------------------------+ //| Gestione delle posizioni aperte | //±-----------------------------------------------------------------+ int HandleOpenPositions() { for (int cnt = OrdersTotal() - 1; cnt >= 0; cnt--) { if (!OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES)) continue; if (OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber) continue;

      if (OrderType() == OP_BUY) {
          // Qui potrebbe andare la logica di uscita per il BUY se necessaria
      } else if (OrderType() == OP_SELL) {
          // E qui quella di uscita per il SELL se necessaria
      }
    

    } return(0); }

    //±-----------------------------------------------------------------+ //| Trailing stop effettivo per una posizione | //±-----------------------------------------------------------------+ void HandleTrailingStop(int tradeType, int ticket, double openPrice, double currentStop, double currentTP) { double point = MarketInfo(Symbol(), MODE_POINT); double newStop;

    if (tradeType == OP_BUY) { double buyTrailStopLevel = openPrice + TrailingStop * point; if (Bid >= buyTrailStopLevel) { newStop = Bid - TrailingStop * point; newStop = NormalizeDouble(newStop, Digits); if (newStop != currentStop) { OrderModify(ticket, openPrice, newStop, currentTP, 0, clrNONE); if (Debug) Print("Modificato il Trailing Stop BUY per il ticket ", ticket); } } } else if (tradeType == OP_SELL) { double sellTrailStopLevel = openPrice - TrailingStop * point; if (Ask <= sellTrailStopLevel) { newStop = Ask + TrailingStop * point; newStop = NormalizeDouble(newStop, Digits); if (newStop != currentStop) { OrderModify(ticket, openPrice, newStop, currentTP, 0, clrNONE); if (Debug) Print("Modificato il Trailing Stop SELL per il ticket ", ticket); } } } }

    //±-----------------------------------------------------------------+ //| Verifica che lo stop loss sia valido e lo normalizza | //±-----------------------------------------------------------------+ double ValidStopLoss(int tradeType, double proposedStop) { double minStopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * MarketInfo(Symbol(), MODE_POINT);

    // Ajusta lo stop loss proposto a seconda se è BUY o SELL if (tradeType == OP_BUY && proposedStop < Ask - minStopLevel) { return (Ask - minStopLevel); } else if (tradeType == OP_SELL && proposedStop > Bid + minStopLevel) { return (Bid + minStopLevel); } return(proposedStop); } //±-----------------------------------------------------------------+ //| Indicatori ausiliari | //±-----------------------------------------------------------------+ int TimeFrame_Const2Val(int Constant) { switch(Constant) { case 1:
    return(1); case 5:
    return(2); case 15: return(3); case 30: return(4); case 60: return(5); case 240: return(6); case 1440: return(7); case 10080: return(8); case 43200: return(9); default: return(-1); // Valore di default se nessun caso è stato abbinato } } //+------------------------------------------------------------------+ //| Time frame string appropriation function | //+------------------------------------------------------------------+ string TimeFrame_Val2String(int Value ) { switch(Value) { case 1:
    return("PERIOD_M1"); case 2:
    return("PERIOD_M5"); case 3: return("PERIOD_M15"); case 4: return("PERIOD_M30"); case 5: return("PERIOD_H1"); case 6: return("PERIOD_H4"); case 7: return("PERIOD_D1"); case 8: return("PERIOD_W1"); case 9: return("PERIOD_MN1"); default: return("undefined " + Value); } } int Symbol2Val(string symbol) { string mySymbol = StringSubstr(symbol,0,6); if(mySymbol=="AUDCAD") return(1); if(mySymbol=="AUDJPY") return(2); if(mySymbol=="AUDNZD") return(3); if(mySymbol=="AUDUSD") return(4); if(mySymbol=="CHFJPY") return(5); if(mySymbol=="EURAUD") return(6); if(mySymbol=="EURCAD") return(7); if(mySymbol=="EURCHF") return(8); if(mySymbol=="EURGBP") return(9); if(mySymbol=="EURJPY") return(10); if(mySymbol=="EURUSD") return(11); if(mySymbol=="GBPCHF") return(12); if(mySymbol=="GBPJPY") return(13); if(mySymbol=="GBPUSD") return(14); if(mySymbol=="NZDUSD") return(15); if(mySymbol=="USDCAD") return(16); if(mySymbol=="USDCHF") return(17); if(mySymbol=="USDJPY") return(18); return(19); }

  44. Assistant

    Per aprire un solo trade per segnale, dobbiamo mantenere uno stato che ricordi se abbiamo già aperto un trade basato su un segnale fornito dalla funzione stochOpen. Aggiungeremo una variabile di stato all'EA per evitare trade multipli sullo stesso segnale.

    Dobbiamo aggiungere una variabile di stato booleana per tenere traccia del fatto se è già stato aperto un trade dopo il segnale rilevato da stochOpen. La variabile può essere aggiunta nella sezione delle variabili interne:

    // ...
    // Variabili interne
    bool isTradeOpened = false; // Variabile per tenere traccia se abbiamo già aperto un trade per il segnale corrente
    double lowlimit = 20;
    double highlimit = 80;
    // ...
    

    Quindi dovrai aggiungere la logica per aggiornare isTradeOpened quando un trade viene aperto e quando tutti i trade sono chiusi:

    1. Modificare OpenBuyOrder e OpenSellOrder per impostare isTradeOpened su true se un ordine viene aperto con successo:
    void OpenBuyOrder() {
        // Se è già stato aperto un trade, non fare nulla
        if (isTradeOpened) return; 
        // ... (logica esistente per aprire un ordine buy)
        // Se OrderSend ha esito positivo e ritorna un ticket valido:
        if(ticket > 0) {
            isTradeOpened = true;
        }
    }
    
    void OpenSellOrder() {
        // Se è già stato aperto un trade, non fare nulla
        if (isTradeOpened) return; 
        // ... (logica esistente per aprire un ordine sell)
        // Se OrderSend ha esito positivo e ritorna un ticket valido:
        if(ticket > 0) {
            isTradeOpened = true;
        }
    }
    
    1. Aggiornare la funzione HandleOpenPositions per resettare isTradeOpened quando non ci sono più posizioni aperte:
    int HandleOpenPositions() {
        int totalOpened = CheckOpenPositions();
        if (totalOpened == 0) {
            isTradeOpened = false; // resetta la variabile se tutti i trade sono stati chiusi
        }
        // ... (resto della logica di gestione posizioni aperte)
    }
    
    1. Assicurarsi che la start non chiami le funzioni di apertura degli ordini se isTradeOpened è già true:
    int start() {
        // ... (logica esistente)
        if (!isTradeOpened) { // Controllo se non ci sono trade aperti
            if(BuySignal()) {
                OpenBuyOrder();
                return(0);
            }
            else if(SellSignal()) {
                OpenSellOrder();
                return(0);
            }
        }
        // ... (resto della funzione start)
    }
    

    Con queste modifiche, il tuo EA aprirà un trade al primo segnale rilevato da stochOpen dopo che tutti i trade sono stati chiusi. Ricorda di testare accuratamente tutte le modifiche in un ambiente sicuro prima di usarle in condizioni reali di trading.

  45. User

    scrivi tuto il blocco int start()

  46. Assistant

    Ecco il blocco int start() con le modifiche suggerite per gestire la logica di apertura di un solo trade per segnale:

    //+------------------------------------------------------------------+
    //| Funzione start()                                                 |
    //+------------------------------------------------------------------+
    int start() {
      // Gestisci le posizioni con Trailing Stop, se necessario
      BeginHandleStopLoss();
      
      // Controlla se è presente una nuova barra
      if (NewBar()) {
          // Gestisci eventuali uscite dalle posizioni aperte
          HandleOpenPositions();
          
          // Se non ci sono posizioni aperte e non è stato già aperto un trade
          // in base al segnale attuale, controlla per nuovi segnali di trading
          if (!isTradeOpened) {
              lotMM = Lots;
              if(BuySignal()) {
                  // Prova ad aprire un ordine di acquisto basato sul segnale
                  OpenBuyOrder();
                  return(0);  // Esce in quanto in caso di successo, un ordine è stato aperto
              }
              else if(SellSignal()) {
                  // Prova ad aprire un ordine di vendita basato sul segnale
                  OpenSellOrder();
                  return(0);  // Esce in quanto in caso di successo, un ordine è stato aperto
              }
          }
      }
      
      // Al termine del ciclo start è tutto apposto
      return(0);  // Se nessuna nuova barra o nessun segnale, termina la funzione
    }
    

    Assicurati che la funzione CheckOpenPositions() che chiami in HandleOpenPositions() sia configurata correttamente per rilevare solo le posizioni aperte che sono interessate dalla tua strategia di trading (ad esempio, utilizzando un MagicNumber univoco). Inoltre, ricorda che per quanto riguarda la funzione OpenBuyOrder() e OpenSellOrder(), devi modificare e implementare la variabile isTradeOpened all'interno di queste funzioni in base al successo dell'apertura di un ordine, come spiegato nei messaggi precedenti.

    Quando tutte le modifiche sono state fatte, compila il tuo EA in MetaTrader 4 (MT4) e testa il nuovo comportamento in un ambiente di test (ad esempio con Strategy Tester) prima di eseguire il tutto su un conto reale.

  47. User

    questo è il risultato, ma non va bene. deve aprire solamente 1 trade ogni volta che si verifica la condizione in cui tutti e 4 gli stocastici sono allineati. ora invece quando il h4 da il segnale apre una posizione ogni volta che se ne chiude un'altra senza attendere il verificarsi di un'altra condizione h4

  48. Assistant

    Per assicurarti che l'EA apra una sola posizione quando tutti e quattro gli stocastici sono allineati, hai bisogno di modificare ulteriormente la logica di trading. Per fare ciò, puoi impostare una variabile che si accerta se è stato aperto un trade sulla base di una specifica condizione H4 e assicurarti che quella condizione venga resettata solo quando viene rilevato un nuovo segnale valido H4.

    Ecco come potresti fare:

    1. Aggiungi una nuova variabile di stato globale per tenere traccia del fatto che la condizione specifica H4 si sia verificata e che un trade sia stato aperto.
    bool h4ConditionMet = false; // Variabile globale per tener traccia dello stato del segnale H4
    
    1. Modifica la funzione stochOpen() per impostare h4ConditionMet quando la condizione è soddisfatta.
    bool StochOpen(string signal) {
       // ... (resto della funzione)
    
       if (signal == "Long") {
           if (main_4Hlast < lowlimit && main_4H > lowlimit && // Verifica il crossover da sotto
               main_15 > lowlimit && main_30 > lowlimit && main_1H > lowlimit) {
               if (!h4ConditionMet) {
                   h4ConditionMet = true; // Imposta il flag quando la condizione è soddisfatta
                   return true; // Vero solo la prima volta che la condizione è soddisfatta
               }
               return false; // Falso in tutte le barre successive fino a quando non viene resettato
           }
       }
       // ... controllo corrispondente per il segnale "Short"
       
       // Se alcuna condizione è stata soddisfatta, resetta il flag
       h4ConditionMet = false; 
       return false; // Nessun trade dovrebbe essere aperto
    }
    
    1. Assicurati che la funzione start() non apra nuovi ordini a meno che la funzione StochOpen() non ritorni true (cioè il segnale viene nuovamente generato). Potrebbe non essere più necessario controllare isTradeOpened, e i controlli sulla nuova barra possono rimanere invariati.
    // Funzione start() e le altre parti del tuo EA
    int start() {
        // Gestisci il trailing stop e chiudi gli ordini se necessario
        BeginHandleStopLoss();
    
        if (NewBar()) {
            HandleOpenPositions(); // Gestisci posizioni aperte per aggiornare il flag di trading
    
            lotMM = Lots;
            
            bool canOpenNewOrder = StochOpen("Long") || StochOpen("Short"); // Verifica condizioni di entrata
            if (canOpenNewOrder && CheckOpenPositions() == 0) {
                if (StochOpen("Long")) {
                    OpenBuyOrder();
                } else if (StochOpen("Short")) {
                    OpenSellOrder();
                }
            }
        }
        return(0);
    }
    
    1. Il reset del flag h4ConditionMet dovrebbe avvenire solo quando gli stocastici non sono più allineati. Non devi resettare h4ConditionMet nella funzione HandleOpenPositions, visto che la funzione StochOpen si occuperà di questo.

    Con questa logica, l'EA aprirà un trade solo quando il segnale H4 viene ricevuto e non aprirà ulteriori trade finché la condizione specifica H4 non si verifica nuovamente.

    Assicurati di testare questi cambiamenti in un ambiente di trading demo per verificare che l'EA operi come desiderato.

  49. User

    riscrivi questo blocco con le modifiche suggerite //±-----------------------------------------------------------------+ //| Analisi Stocastica per i segnali di apertura ordini | //±-----------------------------------------------------------------+ bool StochOpen(string signal) { double main_15 = iStochastic(NULL, PERIOD_M15, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0); double main_30 = iStochastic(NULL, PERIOD_M30, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0); double main_1H = iStochastic(NULL, PERIOD_H1, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0); double main_4H = iStochastic(NULL, PERIOD_H4, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);

    // Ottieni i valori dello stocastico della barra precedente per il 4H double main_4Hlast = iStochastic(NULL, PERIOD_H4, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);

    if (signal == "Long" && main_4Hlast < lowlimit && main_4H > lowlimit && // Verifica il crossover da sotto main_15 > lowlimit && main_30 > lowlimit && main_1H > lowlimit) { return true; }

    if (signal == "Short" && main_4Hlast > highlimit && main_4H < highlimit && // Verifica il crossover da sopra main_15 < highlimit && main_30 < highlimit && main_1H < highlimit) { return true; }

    return false; }

  50. Assistant

    Sulla base delle tue indicazioni e delle necessità espresse nei messaggi precedenti, ecco come potrebbe essere riscritto il blocco StochOpen con le modifiche suggerite:

    // Variabile di stato globale per tenere traccia se un segnale è stato già utilizzato per entrare in un trade
    extern bool h4ConditionMet = false;
    
    //±-----------------------------------------------------------------+
    //| Analisi Stocastica per i segnali di apertura ordini              |
    //±-----------------------------------------------------------------+
    bool StochOpen(string signal) {
       static datetime lastCheckedTime = 0;
       double main_15 = iStochastic(NULL, PERIOD_M15, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);
       double main_30 = iStochastic(NULL, PERIOD_M30, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);
       double main_1H = iStochastic(NULL, PERIOD_H1, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);
       double main_4H = iStochastic(NULL, PERIOD_H4, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);
    
       // Ottieni i valori dello stocastico della barra precedente per il 4H 
       double main_4Hlast = iStochastic(NULL, PERIOD_H4, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
    
       // Verifica se la condizione di ingresso per un segnale Long è stata riscontrata
       if (signal == "Long" &&
           main_4Hlast < lowlimit && main_4H > lowlimit &&
           main_15 > lowlimit && main_30 > lowlimit && main_1H > lowlimit) {
           // Segnaliamo solo una volta per condizione e solo se non è già stata usata per un ingresso
           if (!h4ConditionMet) {
               h4ConditionMet = true; // Marca la condizione come utilizzata
               lastCheckedTime = Time[0]; // Aggiorna il momento dell'ultimo controllo
               return true;
           }
       }
       // Verifica se la condizione di ingresso per un segnale Short è stata riscontrata
       else if (signal == "Short" &&
                main_4Hlast > highlimit && main_4H < highlimit &&
                main_15 < highlimit && main_30 < highlimit && main_1H < highlimit) {
           // Segnaliamo solo una volta per condizione e solo se non è già stata usata per un ingresso
           if (!h4ConditionMet) {
               h4ConditionMet = true; // Marca la condizione come utilizzata
               lastCheckedTime = Time[0]; // Aggiorna il momento dell'ultimo controllo
               return true;
           }
       }
       // Se le condizioni non sono soddisfatte, controlliamo se siamo in un nuovo ciclo del timeframe 4H
       else if (lastCheckedTime != Time[0]) {
           // Se siamo in un nuovo ciclo del timeframe 4H e nessuna condizione è stata riscontrata,
           // resettiamo la variabile h4ConditionMet per permettere future operazioni
           h4ConditionMet = false;
       }
    
       return false;
    }
    

    In questo blocco di codice, il flag h4ConditionMet viene usato per tenere traccia del fatto che la condizione per un determinato segnale (Long o Short) sia stata riscontrata e un trade sia stato aperto. Il flag viene resettato solo quando una nuova barra 4H viene formata e nessuna condizione è soddisfatta.

    La variabile lastCheckedTime è usata per garantire che stiamo controllando il reset del flag h4ConditionMet solo una volta per barra sul timeframe 4H.

    Ricorda di testare il codice in ambiente demo per assicurarti che il funzionamento sia quello desiderato.

  51. User

    //±-----------------------------------------------------------------+ //| SpudFrye Method EA v001.mq4 | //| Copyright © 2024, G.Bassi | //±-----------------------------------------------------------------+ #include <stdlib.mqh> #include <stderror.mqh>

    // Dichiarazione delle variabili esterne extern double Lots = 1; // Dimensione del lotto standard

    // Controllo del profitto extern double StopLoss = 50; // Massimo pip disposti a perdere per posizione extern bool UseTrailingStop = true; // Se utilizzare Trailing Stop extern int TrailingStopType = 2; // Tipo di Trailing Stop (1 immediato, 2 attesa) extern double TrailingStop = 25; // Numero di pips per il trailing stop extern bool UseTakeProfit = true; // Se utilizzare Take Profit extern int TakeProfit = 100; // Massimo livello di profitto raggiungibile extern int Slippage = 3; // Slittamento possibile

    // Intestazioni di etichettatura trade string label = "== scegli 15, 30, 60, 240 (4 ore) per timeframe di uscita"; extern int exittimeframe = 30; // Timeframe di uscita

    // Variabili interne bool isTradeOpened = false; // Variabile per tenere traccia se abbiamo già aperto un trade per il segnale corrente bool h4ConditionMet = false; // Variabile globale per tener traccia dello stato del segnale H4

    double lowlimit = 20; double highlimit = 80; double myStopLoss;
    double lotMM; int MagicNumber; string setup = "";

    // Riprova impostazioni int totalTries = 5; int retryDelay = 1000;

    // Debugging bool Debug=false;

    //±-----------------------------------------------------------------+ //| Funzione di init() | //±-----------------------------------------------------------------+ int init() { MagicNumber = 5000 + Symbol2Val(Symbol()) * 100 + TimeFrame_Const2Val(Period()); setup = "Stoch 5 EA " + Symbol() + "_" + TimeFrame_Val2String(TimeFrame_Const2Val(Period())); return(0); }

    //±-----------------------------------------------------------------+ //| Funzione di deinit() | //±-----------------------------------------------------------------+ int deinit() { // Qui potresti implementare la pulizia delle risorse se necessario return(0); }

    //NormalizeDouble double NormalizePrice(double price) { return(NormalizeDouble(price, Digits)); }

    double GetMinStopLoss(double price, bool isBuy) { double minStopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * Point; if (isBuy) { // Per ordini di acquisto, lo stop loss non può essere inferiore al prezzo corrente più il minStopLevel return(NormalizePrice(price + minStopLevel)); } else { // Per ordini di vendita, lo stop loss non può essere maggiore del prezzo corrente meno il minStopLevel return(NormalizePrice(price - minStopLevel)); } }

    //±-----------------------------------------------------------------+ //| Controlla le posizioni aperte | //±-----------------------------------------------------------------+ int CheckOpenPositions() { int NumBuyTrades = 0, NumSellTrades = 0; for (int i = 0; i < OrdersTotal(); i++) { if (!OrderSelect(i, SELECT_BY_POS, MODE_TRADES) || OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber) continue;

      if (OrderType() == OP_BUY) NumBuyTrades++;
      if (OrderType() == OP_SELL) NumSellTrades++;
    

    } return (NumBuyTrades + NumSellTrades); }

    //±-----------------------------------------------------------------+ //| Funzione start() | //±-----------------------------------------------------------------+ int start() { // Gestisci il trailing stop e chiudi gli ordini se necessario BeginHandleStopLoss();

    if (NewBar()) {
        HandleOpenPositions(); // Gestisci posizioni aperte per aggiornare il flag di trading
    
        lotMM = Lots;
        
        bool canOpenNewOrder = StochOpen("Long") || StochOpen("Short"); // Verifica condizioni di entrata
        if (canOpenNewOrder && CheckOpenPositions() == 0) {
            if (StochOpen("Long")) {
                OpenBuyOrder();
            } else if (StochOpen("Short")) {
                OpenSellOrder();
            }
        }
    }
    return(0);
    

    }

    //±-----------------------------------------------------------------+ //| Delinea se c’è una nuova barra | //±-----------------------------------------------------------------+ bool NewBar() { static datetime lastBarTime = 0; if (Time[0] != lastBarTime) { lastBarTime = Time[0]; return(true); } else { return(false); } }

    //±-----------------------------------------------------------------+ //| Gestisce il trailing stop per tutte le posizioni | //±-----------------------------------------------------------------+ int BeginHandleStopLoss() { for (int cnt = OrdersTotal() - 1; cnt >= 0; cnt--) { if (!OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES)) continue; if (OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber) continue;

      if (OrderType() == OP_BUY || OrderType() == OP_SELL) {
         if (UseTrailingStop) {
            HandleTrailingStop(OrderType(),OrderTicket(),OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit());
         }
      }
    

    } return(0); }

    //±-----------------------------------------------------------------+ //| Segnale di acquisto tramite analisi dello stocastico | //±-----------------------------------------------------------------+ bool BuySignal() { if (StochOpen("Long")) return(true); return(false);
    }

    //±-----------------------------------------------------------------+ //| Segnale di vendita tramite analisi dello stocastico | //±-----------------------------------------------------------------+ bool SellSignal() { if (StochOpen("Short")) return(true); return(false);
    }

    //±-----------------------------------------------------------------+ //| Apertura di un ordine di acquisto | //±-----------------------------------------------------------------+ void OpenBuyOrder() { // Se è già stato aperto un trade, non fare nulla if (isTradeOpened) return;

    double ask = MarketInfo(Symbol(), MODE_ASK);
    double slippagePoints = Slippage * Point;
    double stopBuffer = 2 * MarketInfo(Symbol(), MODE_STOPLEVEL) * Point; // Buffer di sicurezza aggiuntivo
    double myStopLoss = ask - StopLoss * Point - stopBuffer;
    
    myStopLoss = NormalizeDouble(myStopLoss, Digits);
    
    double myTakeProfit = 0;
    if (UseTakeProfit && TakeProfit > 0) {
        myTakeProfit = ask + TakeProfit * Point;
        myTakeProfit = NormalizeDouble(myTakeProfit, Digits);
    }
    
    int ticket = OrderSend(Symbol(), OP_BUY, Lots, NormalizeDouble(ask, Digits), slippagePoints, myStopLoss, myTakeProfit, setup, MagicNumber, 0, clrGreen);
    if (ticket < 0) {
        Print("Error Opening BUY Order: ", GetLastError());
    } 
    // Se OrderSend ha esito positivo e ritorna un ticket valido:
    if(ticket > 0) {
        isTradeOpened = true;
    }
    // Se OrderSend ha esito positivo e ritorna un ticket valido:
    if(ticket > 0) {
        isTradeOpened = true;
    }
    

    }

    void OpenSellOrder() { // Se è già stato aperto un trade, non fare nulla if (isTradeOpened) return;

    double bid = MarketInfo(Symbol(), MODE_BID);
    double slippagePoints = Slippage * Point;
    double stopBuffer = 2 * MarketInfo(Symbol(), MODE_STOPLEVEL) * Point; // Buffer di sicurezza aggiuntivo
    double myStopLoss = bid + StopLoss * Point + stopBuffer;
    
    myStopLoss = NormalizeDouble(myStopLoss, Digits);
    
    double myTakeProfit = 0;
    if (UseTakeProfit && TakeProfit > 0) {
        myTakeProfit = bid - TakeProfit * Point;
        myTakeProfit = NormalizeDouble(myTakeProfit, Digits);
    }
    
    int ticket = OrderSend(Symbol(), OP_SELL, Lots, NormalizeDouble(bid, Digits), slippagePoints, myStopLoss, myTakeProfit, setup, MagicNumber, 0, clrRed);
    if (ticket < 0) {
        Print("Error Opening SELL Order: ", GetLastError());
    } 
    

    }

    //±-----------------------------------------------------------------+ //| Analisi Stocastica per i segnali di apertura ordini | //±-----------------------------------------------------------------+ bool StochOpen(string signal) { static datetime lastCheckedTime = 0; double main_15 = iStochastic(NULL, PERIOD_M15, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0); double main_30 = iStochastic(NULL, PERIOD_M30, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0); double main_1H = iStochastic(NULL, PERIOD_H1, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0); double main_4H = iStochastic(NULL, PERIOD_H4, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);

    // Ottieni i valori dello stocastico della barra precedente per il 4H double main_4Hlast = iStochastic(NULL, PERIOD_H4, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);

    // Verifica se la condizione di ingresso per un segnale Long è stata riscontrata if (signal == "Long" && main_4Hlast < lowlimit && main_4H > lowlimit && main_15 > lowlimit && main_30 > lowlimit && main_1H > lowlimit) { // Segnaliamo solo una volta per condizione e solo se non è già stata usata per un ingresso if (!h4ConditionMet) { h4ConditionMet = true; // Marca la condizione come utilizzata lastCheckedTime = Time[0]; // Aggiorna il momento dell’ultimo controllo return true; } } // Verifica se la condizione di ingresso per un segnale Short è stata riscontrata else if (signal == "Short" && main_4Hlast > highlimit && main_4H < highlimit && main_15 < highlimit && main_30 < highlimit && main_1H < highlimit) { // Segnaliamo solo una volta per condizione e solo se non è già stata usata per un ingresso if (!h4ConditionMet) { h4ConditionMet = true; // Marca la condizione come utilizzata lastCheckedTime = Time[0]; // Aggiorna il momento dell’ultimo controllo return true; } } // Se le condizioni non sono soddisfatte, controlliamo se siamo in un nuovo ciclo del timeframe 4H else if (lastCheckedTime != Time[0]) { // Se siamo in un nuovo ciclo del timeframe 4H e nessuna condizione è stata riscontrata, // resettiamo la variabile h4ConditionMet per permettere future operazioni h4ConditionMet = false; }

    return false; } //±-----------------------------------------------------------------+ //| Gestione delle posizioni aperte | //±-----------------------------------------------------------------+ int HandleOpenPositions() { int totalOpened = CheckOpenPositions(); if (totalOpened == 0) { isTradeOpened = false; // resetta la variabile se tutti i trade sono stati chiusi } for (int cnt = OrdersTotal() - 1; cnt >= 0; cnt--) { if (!OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES)) continue; if (OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber) continue;

      if (OrderType() == OP_BUY) {
          // Qui potrebbe andare la logica di uscita per il BUY se necessaria
      } else if (OrderType() == OP_SELL) {
          // E qui quella di uscita per il SELL se necessaria
      }
    

    } return(0); }

    //±-----------------------------------------------------------------+ //| Trailing stop effettivo per una posizione | //±-----------------------------------------------------------------+ void HandleTrailingStop(int tradeType, int ticket, double openPrice, double currentStop, double currentTP) { double point = MarketInfo(Symbol(), MODE_POINT); double newStop;

    if (tradeType == OP_BUY) { double buyTrailStopLevel = openPrice + TrailingStop * point; if (Bid >= buyTrailStopLevel) { newStop = Bid - TrailingStop * point; newStop = NormalizeDouble(newStop, Digits); if (newStop != currentStop) { OrderModify(ticket, openPrice, newStop, currentTP, 0, clrNONE); if (Debug) Print("Modificato il Trailing Stop BUY per il ticket ", ticket); } } } else if (tradeType == OP_SELL) { double sellTrailStopLevel = openPrice - TrailingStop * point; if (Ask <= sellTrailStopLevel) { newStop = Ask + TrailingStop * point; newStop = NormalizeDouble(newStop, Digits); if (newStop != currentStop) { OrderModify(ticket, openPrice, newStop, currentTP, 0, clrNONE); if (Debug) Print("Modificato il Trailing Stop SELL per il ticket ", ticket); } } } }

    //±-----------------------------------------------------------------+ //| Verifica che lo stop loss sia valido e lo normalizza | //±-----------------------------------------------------------------+ double ValidStopLoss(int tradeType, double proposedStop) { double minStopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * MarketInfo(Symbol(), MODE_POINT);

    // Ajusta lo stop loss proposto a seconda se è BUY o SELL if (tradeType == OP_BUY && proposedStop < Ask - minStopLevel) { return (Ask - minStopLevel); } else if (tradeType == OP_SELL && proposedStop > Bid + minStopLevel) { return (Bid + minStopLevel); } return(proposedStop); } //±-----------------------------------------------------------------+ //| Indicatori ausiliari | //±-----------------------------------------------------------------+ int TimeFrame_Const2Val(int Constant) { switch(Constant) { case 1:
    return(1); case 5:
    return(2); case 15: return(3); case 30: return(4); case 60: return(5); case 240: return(6); case 1440: return(7); case 10080: return(8); case 43200: return(9); default: return(-1); // Valore di default se nessun caso è stato abbinato } } //+------------------------------------------------------------------+ //| Time frame string appropriation function | //+------------------------------------------------------------------+ string TimeFrame_Val2String(int Value ) { switch(Value) { case 1:
    return("PERIOD_M1"); case 2:
    return("PERIOD_M5"); case 3: return("PERIOD_M15"); case 4: return("PERIOD_M30"); case 5: return("PERIOD_H1"); case 6: return("PERIOD_H4"); case 7: return("PERIOD_D1"); case 8: return("PERIOD_W1"); case 9: return("PERIOD_MN1"); default: return("undefined " + Value); } } int Symbol2Val(string symbol) { string mySymbol = StringSubstr(symbol,0,6); if(mySymbol=="AUDCAD") return(1); if(mySymbol=="AUDJPY") return(2); if(mySymbol=="AUDNZD") return(3); if(mySymbol=="AUDUSD") return(4); if(mySymbol=="CHFJPY") return(5); if(mySymbol=="EURAUD") return(6); if(mySymbol=="EURCAD") return(7); if(mySymbol=="EURCHF") return(8); if(mySymbol=="EURGBP") return(9); if(mySymbol=="EURJPY") return(10); if(mySymbol=="EURUSD") return(11); if(mySymbol=="GBPCHF") return(12); if(mySymbol=="GBPJPY") return(13); if(mySymbol=="GBPUSD") return(14); if(mySymbol=="NZDUSD") return(15); if(mySymbol=="USDCAD") return(16); if(mySymbol=="USDCHF") return(17); if(mySymbol=="USDJPY") return(18); return(19); }

    non apre dei trade. credo ci sia un errore. h4ConditionMet funziona nel modo corretto?

  52. Assistant

    Per garantire che l'EA apra un solo trade alla volta quando si verifica la condizione specifica e non continui ad aprire nuovi trade ad ogni tick o nuova barra, dobbiamo fare alcune correzioni.

    Prima di tutto, dobbiamo assicurarci che la variabile h4ConditionMet venga utilizzata correttamente per verificare se un segnale fresco è stato generato dopo che le condizioni di H4 siano state soddisfatte.

    Dobbiamo poi assicurarci che l'EA non apra un nuovo trade finché non si verifica un nuovo segnale dopo che la condizione è stata resettata. Per fare questo, ci affidiamo alla variabile h4ConditionMet per capire quando abbiamo già riconosciuto le condizioni del segnale e aperto un trade, e poi resettiamo questa variabile solo quando le condizioni del segnale non vengono più rilevate. In questo modo preveniamo l'apertura di nuovi trade fino a quando non avviene un nuovo crossover dell'H4 stocastico.

    Ecco come si potrebbe modificare il codice della funzione StochOpen:

    // Dichiarazione globale della variabile
    bool h4ConditionMet = false;
    
    // ...
    
    bool StochOpen(string signal) {
       double main_15 = iStochastic(NULL, PERIOD_M15, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);
       double main_30 = iStochastic(NULL, PERIOD_M30, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);
       double main_1H = iStochastic(NULL, PERIOD_H1, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);
       double main_4H = iStochastic(NULL, PERIOD_H4, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);
       double main_4Hlast = iStochastic(NULL, PERIOD_H4, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
    
       // Aggiorniamo la condizione basata sul segnale H4
       if(!h4ConditionMet && signal == "Long" &&
           main_4H > main_4Hlast && main_4Hlast < lowlimit &&
           main_15 > lowlimit && main_30 > lowlimit && main_1H > lowlimit) {
           h4ConditionMet = true;
           return true;
       } 
       else if(!h4ConditionMet && signal == "Short" &&
           main_4H < main_4Hlast && main_4Hlast > highlimit &&
           main_15 < highlimit && main_30 < highlimit && main_1H < highlimit) {
           h4ConditionMet = true;
           return true;
       }
    
       // Resettiamo la condizione se i prezzi hanno attraversato indietro lo stocastico
       // Questo potrebbe significare che apriremo un trade soltanto se il movimento prosegue
       // come segnale H4 nelle barre successive al crossover.
       else if(h4ConditionMet && 
           ((signal == "Long" && main_4H < lowlimit) || 
           (signal == "Short" && main_4H > highlimit))) {
           h4ConditionMet = false;
       }
    
       return false;
    }
    

    Nelle funzioni OpenBuyOrder e OpenSellOrder, assicuratevi di resettare isTradeOpened solo dopo che un trade è stato chiuso o una nuova condizione è stata soddisfatta:

    // ...
    
    void OpenBuyOrder() {
        if (isTradeOpened) return;
        // ... Resto della logica per aprire un ordine buy
        if (ticket > 0) {
            isTradeOpened = true;
        }
    }
    
    void OpenSellOrder() {
        if (isTradeOpened) return;
        // ... Resto della logica per aprire un ordine sell
        if (ticket > 0) {
            isTradeOpened = true;
        }
    }
    
    // ...
    
    // Questa parte va nel tuo HandleOpenPositions, alla chiusura di tutte le posizioni
    if (totalOpened == 0) {
        isTradeOpened = false;
        h4ConditionMet = false; // Potresti aver bisogno di resettare anche questa se chiudi manualmente
    }
    

    Con queste modifiche, h4ConditionMet ora ricorda quando si verifica la condizione per il segnale H4. Se il trade è chiuso (il che significa che CheckOpenPositions() == 0) e il segnale H4 non è più valido (ad esempio, il valore dello stocastico è di nuovo al di sotto del lowlimit per un "Long"), allora h4ConditionMet viene resettato.

    Questo schema dovrebbe prevenire l'apertura di nuovi trade dopo la chiusura immediata di uno ed invece aspettare che si verifichi un nuovo segnale valido prima di aprire un altro trade.

    Si raccomanda di eseguire test approfonditi in ambiente demo per validare questa logica prima di utilizzarla effettivamente in un contesto di trading live.

  53. User

    riscrivi tutto il blocco StochOpen

  54. Assistant

    Ecco come si può riscrivere il blocco di codice StochOpen seguendo la logica richiesta:

    // Variabile di stato globale
    extern bool h4ConditionMet = false; // Serve ad indicare se le condizioni H4 sono state soddisfatte e il trade è stato aperto
    
    //±-----------------------------------------------------------------+
    //| Analisi Stocastica per i segnali di apertura ordini             |
    //±-----------------------------------------------------------------+
    bool StochOpen(string signal) {
       static datetime lastConditionMetTime;
       
       double main_15 = iStochastic(NULL, PERIOD_M15, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);
       double main_30 = iStochastic(NULL, PERIOD_M30, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);
       double main_1H = iStochastic(NULL, PERIOD_H1, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);
       double main_4H = iStochastic(NULL, PERIOD_H4, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);
       double main_4Hlast = iStochastic(NULL, PERIOD_H4, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
    
       // Verifica la condizione di crossing per il segnale Long
       if (signal == "Long" && !h4ConditionMet &&
           main_4Hlast < lowlimit && main_4H >= lowlimit &&
           main_15 > lowlimit && main_30 > lowlimit && main_1H > lowlimit) {
           h4ConditionMet = true; // Segnala che la condizione H4 è stata soddisfatta
           lastConditionMetTime = Time[0]; // Registra il momento in cui la condizione è stata soddisfatta
           return true;
       }
       // Verifica la condizione di crossing per il segnale Short
       else if (signal == "Short" && !h4ConditionMet &&
                main_4Hlast > highlimit && main_4H <= highlimit &&
                main_15 < highlimit && main_30 < highlimit && main_1H < highlimit) {
           h4ConditionMet = true; // Segnala che la condizione H4 è stata soddisfatta
           lastConditionMetTime = Time[0]; // Registra il momento in cui la condizione è stata soddisfatta
           return true;
       }
       // Se le condizioni di ingresso non sono più soddisfatte, revoca il segnale
       else if (h4ConditionMet &&
                ((signal == "Long" && (main_4H < lowlimit || Time[0] > lastConditionMetTime)) || 
                 (signal == "Short" && (main_4H > highlimit || Time[0] > lastConditionMetTime)))) {
           h4ConditionMet = false;
       }
    
       return false;
    }
    

    In questo blocco:

    • La variabile h4ConditionMet viene settata a true la prima volta che tutte le condizioni relative agli indicatori stocastici sono soddisfatte.
    • lastConditionMetTime tiene traccia dell'ultima volta che le condizioni sono state soddisfatte.
    • Successivamente, se la condizione H4 smette di essere soddisfatta o siamo alla barra successiva dopo quel momento, la variabile h4ConditionMet viene settata a false in attesa di un nuovo segnale per aprire un altro trade.

    Questa modifica garantisce che l'EA apra un trade solo con il primo segnale di allineamento degli stocastici dopo il reset delle condizioni. Ricorda di aggiornare il resto del tuo EA di conseguenza per utilizzare correttamente la variabile h4ConditionMet.

    È altresì importante che il resto del tuo codice consideri la variabile h4ConditionMet quando gestisce l'apertura di nuovi trade. Assicurati di testare le nuove modifiche in un ambiente di demo prima di applicarle in un contesto di trading reale.

  55. User

    ci deve essere qualche errore perhcè non apre più nessun trade

  56. Assistant

    Mi scuso per la confusione. Se l'EA non apre più nessun trade, dobbiamo esaminare la logica del segnale e assicurarci che sia corretta e che il segnale venga generato come previsto. Potrebbe esserci un problema con la condizione che verifica il segnale o con la gestione della variabile h4ConditionMet.

    Diamo un'occhiata al codice e rivediamolo:

    // Variabile di stato globale
    bool h4ConditionMet = false; // Init a false perché all'inizio non c'è alcun segnale
    
    //±-----------------------------------------------------------------+
    //| Analisi Stocastica per i segnali di apertura ordini              |
    //±-----------------------------------------------------------------+
    bool StochOpen(string signal) {
       // Ottieni i valori attuali dello stocastico per tutti i timeframe
       double main_15 = iStochastic(NULL, PERIOD_M15, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
       double main_30 = iStochastic(NULL, PERIOD_M30, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
       double main_1H = iStochastic(NULL, PERIOD_H1, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
       double main_4H = iStochastic(NULL, PERIOD_H4, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
       
       // Ottieni i valori dello stocastico della barra precedente per il 4H 
       double main_4Hprev = iStochastic(NULL, PERIOD_H4, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 2);
       
       // Se stiamo cercando un segnale long e il 4H è appena passato sopra il lowlimit
       if (signal == "Long" && main_4Hprev < lowlimit && main_4H >= lowlimit) {
           // Verifica che tutti gli altri timeframe stiano mostrando valori sopra il lowlimit
           if ( main_15 >= lowlimit && main_30 >= lowlimit && main_1H >= lowlimit) {
               // Se non è ancora stato dato un segnale dall'H4, impostiamo il segnale e ritorniamo true
               if (!h4ConditionMet) {
                   h4ConditionMet = true; // Set il flag a true per prevenire che altri trade si aprano
                   return true;
               }
           }
       }
       // Se stiamo cercando un segnale short e il 4H è appena passato sotto l'highlimit
       else if (signal == "Short" &&  main_4Hprev > highlimit && main_4H <= highlimit) {
           // Verifica che tutti gli altri timeframe stiano mostrando valori sotto l'highlimit
           if ( main_15 <= highlimit && main_30 <= highlimit && main_1H <= highlimit) {
               // Se non è ancora stato dato un segnale dall'H4, impostiamo il segnale e ritorniamo true
               if (!h4ConditionMet) {
                   h4ConditionMet = true; // Set il flag a true per prevenire che altri trade si aprano
                   return true;
               }
           }
       }
    
       // Se non siamo in presenza di una nuova barra sul timeframe H4, non resettiamo il segnale
       if (Time[0] % Period() != 0) {
           // La barra H4 non è ancora completa, quindi non resettare ancora h4ConditionMet
           return false;
       }
    
       // Se non si è verificata alcuna nuova azione di prezzo che confermi il segnale H4, lo resetta
       if ((signal == "Long" && main_4H < lowlimit) || (signal == "Short" && main_4H > highlimit)) {
           h4ConditionMet = false; // Resetta il flag se il prezzo attraversa nuovamente il soglia indicante il segnale opposto
       }
    
       return false;
    }
    

    Altre cose da controllare:

    • Assicurati che le funzioni OpenBuyOrder e OpenSellOrder vengano chiamate correttamente dopo che il segnale è stato generato.
    • Verifica che lowlimit e highlimit siano impostati correttamente e che i valori calcolati con iStochastic siano coerenti con la tua strategia di trading.
    • Controlla che tutte le altre parti dell'EA, come start() e CheckOpenPositions(), funzionino come atteso.

    Ricordati di provare qualsiasi cambio in un ambiente sicuro e di fare un backtesting approfondito per assicurarti che l'EA si comporti come desiderato prima di metterlo in uso su un conto di trading reale.

  57. User

    //±-----------------------------------------------------------------+ //| SpudFrye Method EA v001.mq4 | //| Copyright © 2024, G.Bassi | //±-----------------------------------------------------------------+ #include <stdlib.mqh> #include <stderror.mqh>

    // Dichiarazione delle variabili esterne extern double Lots = 1; // Dimensione del lotto standard

    // Controllo del profitto extern double StopLoss = 50; // Massimo pip disposti a perdere per posizione extern bool UseTrailingStop = true; // Se utilizzare Trailing Stop extern int TrailingStopType = 2; // Tipo di Trailing Stop (1 immediato, 2 attesa) extern double TrailingStop = 25; // Numero di pips per il trailing stop extern bool UseTakeProfit = true; // Se utilizzare Take Profit extern int TakeProfit = 100; // Massimo livello di profitto raggiungibile extern int Slippage = 3; // Slittamento possibile

    // Intestazioni di etichettatura trade string label = "== scegli 15, 30, 60, 240 (4 ore) per timeframe di uscita"; extern int exittimeframe = 30; // Timeframe di uscita

    // Variabili interne bool isTradeOpened = false; // Variabile per tenere traccia se abbiamo già aperto un trade per il segnale corrente bool h4ConditionMet = false; // Variabile globale per tener traccia dello stato del segnale H4

    double lowlimit = 20; double highlimit = 80; double myStopLoss;
    double lotMM; int MagicNumber; string setup = "";

    // Riprova impostazioni int totalTries = 5; int retryDelay = 1000;

    // Debugging bool Debug=false;

    //±-----------------------------------------------------------------+ //| Funzione di init() | //±-----------------------------------------------------------------+ int init() { MagicNumber = 5000 + Symbol2Val(Symbol()) * 100 + TimeFrame_Const2Val(Period()); setup = "Stoch 5 EA " + Symbol() + "_" + TimeFrame_Val2String(TimeFrame_Const2Val(Period())); return(0); }

    //±-----------------------------------------------------------------+ //| Funzione di deinit() | //±-----------------------------------------------------------------+ int deinit() { // Qui potresti implementare la pulizia delle risorse se necessario return(0); }

    //NormalizeDouble double NormalizePrice(double price) { return(NormalizeDouble(price, Digits)); }

    double GetMinStopLoss(double price, bool isBuy) { double minStopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * Point; if (isBuy) { // Per ordini di acquisto, lo stop loss non può essere inferiore al prezzo corrente più il minStopLevel return(NormalizePrice(price + minStopLevel)); } else { // Per ordini di vendita, lo stop loss non può essere maggiore del prezzo corrente meno il minStopLevel return(NormalizePrice(price - minStopLevel)); } }

    //±-----------------------------------------------------------------+ //| Controlla le posizioni aperte | //±-----------------------------------------------------------------+ int CheckOpenPositions() { int NumBuyTrades = 0, NumSellTrades = 0; for (int i = 0; i < OrdersTotal(); i++) { if (!OrderSelect(i, SELECT_BY_POS, MODE_TRADES) || OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber) continue;

      if (OrderType() == OP_BUY) NumBuyTrades++;
      if (OrderType() == OP_SELL) NumSellTrades++;
    

    } return (NumBuyTrades + NumSellTrades); }

    //±-----------------------------------------------------------------+ //| Funzione start() | //±-----------------------------------------------------------------+ int start() { // Gestisci il trailing stop e chiudi gli ordini se necessario BeginHandleStopLoss();

    if (NewBar()) {
        HandleOpenPositions(); // Gestisci posizioni aperte per aggiornare il flag di trading
    
        lotMM = Lots;
        
        bool canOpenNewOrder = StochOpen("Long") || StochOpen("Short"); // Verifica condizioni di entrata
        if (canOpenNewOrder && CheckOpenPositions() == 0) {
            if (StochOpen("Long")) {
                OpenBuyOrder();
            } else if (StochOpen("Short")) {
                OpenSellOrder();
            }
        }
    }
    return(0);
    

    }

    //±-----------------------------------------------------------------+ //| Delinea se c’è una nuova barra | //±-----------------------------------------------------------------+ bool NewBar() { static datetime lastBarTime = 0; if (Time[0] != lastBarTime) { lastBarTime = Time[0]; return(true); } else { return(false); } }

    //±-----------------------------------------------------------------+ //| Gestisce il trailing stop per tutte le posizioni | //±-----------------------------------------------------------------+ int BeginHandleStopLoss() { for (int cnt = OrdersTotal() - 1; cnt >= 0; cnt--) { if (!OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES)) continue; if (OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber) continue;

      if (OrderType() == OP_BUY || OrderType() == OP_SELL) {
         if (UseTrailingStop) {
            HandleTrailingStop(OrderType(),OrderTicket(),OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit());
         }
      }
    

    } return(0); }

    //±-----------------------------------------------------------------+ //| Segnale di acquisto tramite analisi dello stocastico | //±-----------------------------------------------------------------+ bool BuySignal() { if (StochOpen("Long")) return(true); return(false);
    }

    //±-----------------------------------------------------------------+ //| Segnale di vendita tramite analisi dello stocastico | //±-----------------------------------------------------------------+ bool SellSignal() { if (StochOpen("Short")) return(true); return(false);
    }

    //±-----------------------------------------------------------------+ //| Apertura di un ordine di acquisto | //±-----------------------------------------------------------------+ void OpenBuyOrder() { // Se è già stato aperto un trade, non fare nulla if (isTradeOpened) return;

    double ask = MarketInfo(Symbol(), MODE_ASK);
    double slippagePoints = Slippage * Point;
    double stopBuffer = 2 * MarketInfo(Symbol(), MODE_STOPLEVEL) * Point; // Buffer di sicurezza aggiuntivo
    double myStopLoss = ask - StopLoss * Point - stopBuffer;
    
    myStopLoss = NormalizeDouble(myStopLoss, Digits);
    
    double myTakeProfit = 0;
    if (UseTakeProfit && TakeProfit > 0) {
        myTakeProfit = ask + TakeProfit * Point;
        myTakeProfit = NormalizeDouble(myTakeProfit, Digits);
    }
    
    int ticket = OrderSend(Symbol(), OP_BUY, Lots, NormalizeDouble(ask, Digits), slippagePoints, myStopLoss, myTakeProfit, setup, MagicNumber, 0, clrGreen);
    if (ticket < 0) {
        Print("Error Opening BUY Order: ", GetLastError());
    } 
    // Se OrderSend ha esito positivo e ritorna un ticket valido:
    if(ticket > 0) {
        isTradeOpened = true;
    }
    // Se OrderSend ha esito positivo e ritorna un ticket valido:
    if(ticket > 0) {
        isTradeOpened = true;
    }
    

    }

    void OpenSellOrder() { // Se è già stato aperto un trade, non fare nulla if (isTradeOpened) return;

    double bid = MarketInfo(Symbol(), MODE_BID);
    double slippagePoints = Slippage * Point;
    double stopBuffer = 2 * MarketInfo(Symbol(), MODE_STOPLEVEL) * Point; // Buffer di sicurezza aggiuntivo
    double myStopLoss = bid + StopLoss * Point + stopBuffer;
    
    myStopLoss = NormalizeDouble(myStopLoss, Digits);
    
    double myTakeProfit = 0;
    if (UseTakeProfit && TakeProfit > 0) {
        myTakeProfit = bid - TakeProfit * Point;
        myTakeProfit = NormalizeDouble(myTakeProfit, Digits);
    }
    
    int ticket = OrderSend(Symbol(), OP_SELL, Lots, NormalizeDouble(bid, Digits), slippagePoints, myStopLoss, myTakeProfit, setup, MagicNumber, 0, clrRed);
    if (ticket < 0) {
        Print("Error Opening SELL Order: ", GetLastError());
    } 
    

    }

    //±-----------------------------------------------------------------+ //| Analisi Stocastica per i segnali di apertura ordini | //±-----------------------------------------------------------------+ bool StochOpen(string signal) { // Ottieni i valori attuali dello stocastico per tutti i timeframe double main_15 = iStochastic(NULL, PERIOD_M15, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1); double main_30 = iStochastic(NULL, PERIOD_M30, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1); double main_1H = iStochastic(NULL, PERIOD_H1, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1); double main_4H = iStochastic(NULL, PERIOD_H4, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);

    // Ottieni i valori dello stocastico della barra precedente per il 4H double main_4Hprev = iStochastic(NULL, PERIOD_H4, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 2);

    // Se stiamo cercando un segnale long e il 4H è appena passato sopra il lowlimit if (signal == "Long" && main_4Hprev < lowlimit && main_4H >= lowlimit) { // Verifica che tutti gli altri timeframe stiano mostrando valori sopra il lowlimit if ( main_15 >= lowlimit && main_30 >= lowlimit && main_1H >= lowlimit) { // Se non è ancora stato dato un segnale dall’H4, impostiamo il segnale e ritorniamo true if (!h4ConditionMet) { h4ConditionMet = true; // Set il flag a true per prevenire che altri trade si aprano return true; } } } // Se stiamo cercando un segnale short e il 4H è appena passato sotto l’highlimit else if (signal == "Short" && main_4Hprev > highlimit && main_4H <= highlimit) { // Verifica che tutti gli altri timeframe stiano mostrando valori sotto l’highlimit if ( main_15 <= highlimit && main_30 <= highlimit && main_1H <= highlimit) { // Se non è ancora stato dato un segnale dall’H4, impostiamo il segnale e ritorniamo true if (!h4ConditionMet) { h4ConditionMet = true; // Set il flag a true per prevenire che altri trade si aprano return true; } } }

    // Se non siamo in presenza di una nuova barra sul timeframe H4, non resettiamo il segnale if (Time[0] % Period() != 0) { // La barra H4 non è ancora completa, quindi non resettare ancora h4ConditionMet return false; }

    // Se non si è verificata alcuna nuova azione di prezzo che confermi il segnale H4, lo resetta if ((signal == "Long" && main_4H < lowlimit) || (signal == "Short" && main_4H > highlimit)) { h4ConditionMet = false; // Resetta il flag se il prezzo attraversa nuovamente il soglia indicante il segnale opposto }

    return false; } //±-----------------------------------------------------------------+ //| Gestione delle posizioni aperte | //±-----------------------------------------------------------------+ int HandleOpenPositions() { int totalOpened = CheckOpenPositions(); if (totalOpened == 0) { isTradeOpened = false; h4ConditionMet = false; // Potresti aver bisogno di resettare anche questa se chiudi manualmente } for (int cnt = OrdersTotal() - 1; cnt >= 0; cnt--) { if (!OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES)) continue; if (OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber) continue;

      if (OrderType() == OP_BUY) {
          // Qui potrebbe andare la logica di uscita per il BUY se necessaria
      } else if (OrderType() == OP_SELL) {
          // E qui quella di uscita per il SELL se necessaria
      }
    

    } return(0); }

    //±-----------------------------------------------------------------+ //| Trailing stop effettivo per una posizione | //±-----------------------------------------------------------------+ void HandleTrailingStop(int tradeType, int ticket, double openPrice, double currentStop, double currentTP) { double point = MarketInfo(Symbol(), MODE_POINT); double newStop;

    if (tradeType == OP_BUY) { double buyTrailStopLevel = openPrice + TrailingStop * point; if (Bid >= buyTrailStopLevel) { newStop = Bid - TrailingStop * point; newStop = NormalizeDouble(newStop, Digits); if (newStop != currentStop) { OrderModify(ticket, openPrice, newStop, currentTP, 0, clrNONE); if (Debug) Print("Modificato il Trailing Stop BUY per il ticket ", ticket); } } } else if (tradeType == OP_SELL) { double sellTrailStopLevel = openPrice - TrailingStop * point; if (Ask <= sellTrailStopLevel) { newStop = Ask + TrailingStop * point; newStop = NormalizeDouble(newStop, Digits); if (newStop != currentStop) { OrderModify(ticket, openPrice, newStop, currentTP, 0, clrNONE); if (Debug) Print("Modificato il Trailing Stop SELL per il ticket ", ticket); } } } }

    //±-----------------------------------------------------------------+ //| Verifica che lo stop loss sia valido e lo normalizza | //±-----------------------------------------------------------------+ double ValidStopLoss(int tradeType, double proposedStop) { double minStopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * MarketInfo(Symbol(), MODE_POINT);

    // Ajusta lo stop loss proposto a seconda se è BUY o SELL if (tradeType == OP_BUY && proposedStop < Ask - minStopLevel) { return (Ask - minStopLevel); } else if (tradeType == OP_SELL && proposedStop > Bid + minStopLevel) { return (Bid + minStopLevel); } return(proposedStop); } //±-----------------------------------------------------------------+ //| Indicatori ausiliari | //±-----------------------------------------------------------------+ int TimeFrame_Const2Val(int Constant) { switch(Constant) { case 1:
    return(1); case 5:
    return(2); case 15: return(3); case 30: return(4); case 60: return(5); case 240: return(6); case 1440: return(7); case 10080: return(8); case 43200: return(9); default: return(-1); // Valore di default se nessun caso è stato abbinato } } //+------------------------------------------------------------------+ //| Time frame string appropriation function | //+------------------------------------------------------------------+ string TimeFrame_Val2String(int Value ) { switch(Value) { case 1:
    return("PERIOD_M1"); case 2:
    return("PERIOD_M5"); case 3: return("PERIOD_M15"); case 4: return("PERIOD_M30"); case 5: return("PERIOD_H1"); case 6: return("PERIOD_H4"); case 7: return("PERIOD_D1"); case 8: return("PERIOD_W1"); case 9: return("PERIOD_MN1"); default: return("undefined " + Value); } } int Symbol2Val(string symbol) { string mySymbol = StringSubstr(symbol,0,6); if(mySymbol=="AUDCAD") return(1); if(mySymbol=="AUDJPY") return(2); if(mySymbol=="AUDNZD") return(3); if(mySymbol=="AUDUSD") return(4); if(mySymbol=="CHFJPY") return(5); if(mySymbol=="EURAUD") return(6); if(mySymbol=="EURCAD") return(7); if(mySymbol=="EURCHF") return(8); if(mySymbol=="EURGBP") return(9); if(mySymbol=="EURJPY") return(10); if(mySymbol=="EURUSD") return(11); if(mySymbol=="GBPCHF") return(12); if(mySymbol=="GBPJPY") return(13); if(mySymbol=="GBPUSD") return(14); if(mySymbol=="NZDUSD") return(15); if(mySymbol=="USDCAD") return(16); if(mySymbol=="USDCHF") return(17); if(mySymbol=="USDJPY") return(18); return(19); }

    ancora nessun trade aperto. è tutto corretto nel codice?

  58. Assistant

    Nel codice fornito, la logica nell'EA sembra corretta, ma ci sono alcune modifiche minori da fare per assicurarsi che h4ConditionMet sia usato nel modo corretto. Infatti, sembra che le variabili isTradeOpened e h4ConditionMet facciano lo stesso lavoro. Dovremmo usare solo h4ConditionMet per controllare se abbiamo già agito sul segnale corrente.

    Ecco la modifica da apportare alla funzione StochOpen:

    Innanzitutto, rimuoviamo questa riga dal blocco in alto, dato che questa variabile verrà dichiarata come variabile globale e non come extern (non deve essere esposta come una variabile del pannello delle impostazioni dell'utente):

    // Questa linea va rimossa, dato che dichiareremo h4ConditionMet nel corpo del codice
    extern bool h4ConditionMet = false;
    

    Dichiarare h4ConditionMet come variabile globale all'inizio del codice, dopo le altre dichiarazioni delle variabili:

    // Dopo l'ultima variabile esterna e prima di qualsiasi funzione
    bool h4ConditionMet = false;
    

    Ora ecco il modo corretto di utilizzare h4ConditionMet nella funzione StochOpen:

    bool StochOpen(string signal) {
       static datetime lastCheckedTime = 0; // Salva l'ultimo momento in cui è stata controllata la condizione
       if (Time[0] != lastCheckedTime) {
           // Se all'inizio di una nuova barra H4, resettiamo la condizione per consentire nuovi segnali
           lastCheckedTime = Time[0];
           h4ConditionMet = false;
       }
    
       //... resto del codice per calcolo stocastico rimane uguale ...
    
       // Alla fine della funzione, dopo il codice per il calcolo stocastico:
       if (signal == "Long") {
           // Condizione per un segnale long
           if (!h4ConditionMet && main_15 > lowlimit && main_30 > lowlimit && main_1H > lowlimit && main_4H > main_4Hlast && main_4Hlast < lowlimit) {
               h4ConditionMet = true; // Impostiamo la condizione a true per un segnale verificato
               return true; // Ritorna true per indicare che c'è un segnale per entrare long
           }
       }
       else if (signal == "Short") {
           // Condizione per un segnale short
           if (!h4ConditionMet && main_15 < highlimit && main_30 < highlimit && main_1H < highlimit && main_4H < main_4Hlast && main_4Hlast > highlimit) {
               h4ConditionMet = true; // Impostiamo la condizione a true per un segnale verificato
               return true; // Ritorna true per indicare che c'è un segnale per entrare short
           }
       }
       return false; // Ritorna false se non ci sono segnali validi
    }
    

    Nella tua funzione start(), dovresti quindi chiamare StochOpen una sola volta all'inizio e poi usare il valore di ritorno di quella chiamata per decidere se aprire o meno un ordine, invece di chiamare StochOpen più volte. Ad esempio:

    int start() {
       //... Trailing stop e gestione esistente ...
       if(NewBar() && CheckOpenPositions() == 0) {
           if(StochOpen("Long")) {
               OpenBuyOrder();
           } else if(StochOpen("Short")) {
               OpenSellOrder();
           }
       }
       // ... resto del codice di gestione ...
    }
    

    Infine, assicurati che nelle tue funzioni OpenBuyOrder() e OpenSellOrder(), quando chiudi un ordine con profitto o stop loss, h4ConditionMet sia resettato.

    Assicurati di testare qualsiasi cambio del codice in un ambiente di simulazione prima di utilizzarlo nel trading dal vivo. Ciò aiuterà a prevenire errori e perdite inaspettate.

  59. User

    riscrivi tutta la funzione StochOpen

  60. Assistant

    Certamente, riscriveremo la funzione StochOpen per assicurare che apra un trade solo quando si verifica la condizione corretta e che segnali nuovi trade solo quando lo stocastico di H4 attraversa nuovamente i limiti:

    // Variabili globali
    extern bool h4ConditionMet = false;
    
    //±-----------------------------------------------------------------+
    //| Analisi Stocastica per i segnali di apertura ordini             |
    //±-----------------------------------------------------------------+
    bool StochOpen(string signal) {
       // Ottieni i valori attuali dello stocastico per tutti i timeframe
       double main_15 = iStochastic(NULL, PERIOD_M15, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);
       double main_30 = iStochastic(NULL, PERIOD_M30, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);
       double main_1H = iStochastic(NULL, PERIOD_H1, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);
       double main_4H = iStochastic(NULL, PERIOD_H4, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);
       double main_4Hprev = iStochastic(NULL, PERIOD_H4, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
    
       // Se già abbiamo rilevato un segnale ed è aperta una posizione, non cercare ulteriori segnali
       if (h4ConditionMet) {
           return false;
       }
    
       // Controlla la condizione per un Long
       if (signal == "Long" && 
           main_4H > lowlimit && main_4Hprev < lowlimit &&  // Controlla se abbiamo appena superato il lowlimit su H4
           main_15 > lowlimit && main_30 > lowlimit && main_1H > lowlimit) { 
           // Imposta il flag per evitare ulteriori trade fino al prossimo reset
           h4ConditionMet = true;
           return true;
       } 
       
       // Controlla la condizione per un Short
       if (signal == "Short" && 
           main_4H < highlimit && main_4Hprev > highlimit && // Controlla se abbiamo appena scenduto sotto l'highlimit su H4
           main_15 < highlimit && main_30 < highlimit && main_1H < highlimit) {
           // Imposta il flag per evitare ulteriori trade fino al prossimo reset
           h4ConditionMet = true;
           return true;
       }
    
       // Aggiungi un controllo per resettare il flag "h4ConditionMet" se le condizioni per il segnale non sono più vere
       // Per esempio, potresti volerlo fare all'inizio di una nuova barra di H4
       if (NewBarH4()) {
           h4ConditionMet = false;
       }
    
       // Se non ci sono state condizioni per un nuovo segnale, ritorna false
       return false;
    }
    
    //±-----------------------------------------------------------------+
    //| Rileva la nuova barra del timeframe H4                           |
    //±-----------------------------------------------------------------+
    bool NewBarH4() {
        static datetime lastBarTimeH4 = 0;
        datetime currentTimeH4 = iTime(Symbol(), PERIOD_H4, 0);
        if (currentTimeH4 != lastBarTimeH4) {
            lastBarTimeH4 = currentTimeH4;
            return true;
        } else {
            return false;
        }
    }
    

    In questo codice abbiamo:

    • Definito una variabile globale h4ConditionMet per tracciare se un certo segnale è stato già sfruttato per aprire un trade.
    • Implementato la funzione StochOpen per rilevare la condizione corretta basata sullo stocastico sui quattro timeframe.
    • Usato h4ConditionMet per evitare di segnalare ulteriori opportunità di trade finché non si verifica un reset con NewBarH4.

    Assicurati che in start() e nelle altre funzioni, StochOpen venga chiamata correttamente e i trade non vengano aperti se h4ConditionMet è impostato su true.

    È importante poi testare queste modifiche in un ambiente demo per garantire che l'EA funzioni correttamente prima di portarlo su un conto di trading reale.

  61. User

    riscrivi anche la funzione int start corretta

  62. Assistant

    Ecco come riscrivere la funzione start per utilizzare correttamente la variabile h4ConditionMet e assicurarsi di aprire soltanto un trade quando si verifica la condizione di allineamento degli stocastici di H4:

    //+------------------------------------------------------------------+
    //| Funzione start()                                                 |
    //+------------------------------------------------------------------+
    int start() {
        // Gestisce il trailing stop e chiude gli ordini se necessario.
        BeginHandleStopLoss();
    
        // Si assicura che vengano gestiti solo gli eventi quando una nuova barra appare nel timeframe corrente.
        if(NewBar()) {
            // Aggiorna il flag di trading e gestisce le condizioni di uscita delle posizioni.
            HandleOpenPositions();
    
            // Controlla se H4 ha emesso un segnale e non ci sono posizioni aperte.
            if(!h4ConditionMet && CheckOpenPositions() == 0) {
                // Verifica se ci sono nuove condizioni di trading da parte dello stocastico.
                if(BuySignal()) {
                    h4ConditionMet = true; // Imposta il flag perché stiamo per aprire una posizione basata su questo segnale.
                    OpenBuyOrder();
                } else if(SellSignal()) {
                    h4ConditionMet = true; // Imposta il flag perché stiamo per aprire una posizione basata su questo segnale.
                    OpenSellOrder();
                }
            }
        }
        
        // Resetta h4ConditionMet all'inizio di una nuova barra H4 se nessun trade è aperto.
        // Questo reset non sembra essere necessario nel contesto di questo codice, 
        // a meno che non ci siano altre condizioni esterne o una logica separata 
        // che chiude i trades indipendentemente da NewBar().
        // Se fosse necessario resettare h4ConditionMet in altri casi, si dovrebbe aggiungere qui la logica corretta.
    
        return(0); // Termina la funzione.
    }
    

    In questo snippet di codice, h4ConditionMet è utilizzato all'interno di start() per assicurarsi che venga aperto un solo trade dopo aver ricevuto il segnale da H4. Dopo aver aperto una posizione (sia essa long o short), h4ConditionMet viene impostato a true per prevenire l'apertura di nuove posizioni finché la condizione di H4 non viene resettata (cioè manca la chiamata a NewBarH4()).

    E' importante notare che la chiamata a BuySignal() e SellSignal() dovrebbe essere fatta una volta sola all'inizio della start(), altrimenti potrebbero causare la re-impostazione di h4ConditionMet più volte.

    Infine, non dimenticare di assicurarti che la logica di h4ConditionMet sia coerente in tutto l'EA, e che questo flag venga resettato solo basandosi sulla logica della strategia di trading e non solo in base al passer dei ticks o delle barre temporali.

    Ricorda anche di testare il comportamento del tuo EA in un ambiente di demo prima di andare live con esso.

  63. User

    credo di aver capito l'errore: la condizione deve partire quando il h4 è superiore al lowlimit, ma il trade deve partire solamente quando si è già chiusa la candela (H4) altrimenti apre e chiude dei trade in m15 mentre lo stocastico è ancora in movimento

  64. Assistant

    Hai ragione, per evitare di aprire o chiudere trade prematuramente, dovresti aprire un trade solo alla chiusura della candela H4 che soddisfa le condizioni. Questo significa che devi registrare quando riscontri il segnale e poi agire su di esso solo all'inizio della candela successiva, per assicurarti che tutte le condizioni siano state verificate con una candela completa.

    Per farlo, devi tenere traccia del tempo dell'ultima candela in cui è stata identificata la condizione e confrontare tale tempo con il tempo dell'ultima candela chiusa.

    Modifichiamo la funzione StochOpen per implementare questa logica:

    bool stochOpenCondition = false;  // Aggiunta al blocco delle variabili globali
    datetime last4HBarTime;
    
    bool StochOpen(string signal) {
       // Controllo iniziale se siamo all'inizio della nuova candela H4 e reset del segnale se necessario
       datetime current4HBarTime = iTime(Symbol(), PERIOD_H4, 0);
       if (last4HBarTime != current4HBarTime) {
           last4HBarTime = current4HBarTime;
           if (stochOpenCondition) {
               stochOpenCondition = false;  // Reset della condizione all'inizio di una nuova barra H4 se il segnale era stato precedentemente impostato
               return true;  // Se la condizione era vera alla chiusura della precedente candela H4, restituiamo true per aprire un trade
           }
       }
    
       double main_15 = iStochastic(NULL, PERIOD_M15, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);
       double main_30 = iStochastic(NULL, PERIOD_M30, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);
       double main_1H = iStochastic(NULL, PERIOD_H1, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);
       double main_4H = iStochastic(NULL, PERIOD_H4, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);
       double main_4Hlast = iStochastic(NULL, PERIOD_H4, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
    
       // Verifica delle condizioni senza cambiare alcuna azione fino alla nuova barra H4
       if (signal == "Long" && 
           main_4H > lowlimit && main_4Hlast < lowlimit && 
           main_15 > lowlimit && main_30 > lowlimit && main_1H > lowlimit) {
           stochOpenCondition = true;  // Impostazione del segnale al verificarsi della condizione
       } 
       else if (signal == "Short" &&
                main_4H < highlimit && main_4Hlast > highlimit &&
                main_15 < highlimit && main_30 < highlimit && main_1H < highlimit) { 
           stochOpenCondition = true;  // Impostazione del segnale al verificarsi della condizione
       }
       
       return false;  // Nessuna azione intrapresa fino alla chiusura della barra H4 corrente
    }
    

    Questa modifica assicura che la tua funzione stochOpen tenga traccia di una condizione di ingresso verificatasi durante la bara corrente di H4 e agisca (aprendo un trade) solo all'inizio della barra di H4 successiva.

    Ricorda di rimuovere le chiamate a StochOpen dalla tua funzione start tranne una sola chiamata, o potresti erroneamente resettare il segnale prima che la candela si chiuda. Sempre nella start, devi anche assicurarti di non chiamare OpenBuyOrder o OpenSellOrder se stochOpenCondition è false.

    Nota che la variabile stochOpenCondition è globale e va dichiarata all'inizio del codice con le altre variabili globali, mentre last4HBarTime è dichiarata all'interno di StochOpen.

    Infine, testa tutte le modifiche con Strategy Tester su MT4 per essere sicuro che il comportamento sia conforme al previsto prima di avventurarti con il trading real.

  65. User

    sembra funzionare su eurusd con stoploss a 150 e take profit a 300 timeframe 1h. ha un buon ritorno, 76% di segnali con guadagno. su gbpusd invece perde molti soldi. sapresti dirmi perchè? cosa dovrei cambiare nei settaggi?

  66. Assistant

    Il fatto che l'EA funzioni bene su EURUSD ma non su GBPUSD indica che la strategia potrebbe essere più adatta alla volatilità e alle caratteristiche del mercato specifiche di EURUSD. Ci sono diverse ragioni per cui una strategia di trading potrebbe funzionare su una coppia di valute ma non su un'altra, tra cui:

    1. Volatilità del Mercato: Diverse coppie di valute hanno livelli di volatilità diversi. GBPUSD tende ad essere più volatile di EURUSD, il che può influenzare l'efficacia di una strategia basata su indicatori come lo stocastico.

    2. Comportamento del Mercato: Ogni coppia di valute ha il suo "comportamento" unico, influenzato da fattori economici, annunci, sessioni di trading, e così via. Questo può incidere su come i prezri si muovono e su come gli indicatori sono da interpretare.

    3. Impostazioni degli Indicatori: Può essere necessario modificare le impostazioni dello stocastico (o di altri indicatori utilizzati) per adattarsi meglio al ritmo dei movimenti di prezzo in GBPUSD.

    4. Orari di Trading: A seconda degli orari di trading e delle sessioni di mercato (asiatica, europea, americana), le coppie possono comportarsi diversamente. Queste differenze possono rendere una strategia meno efficace se non viene presa in considerazione la temporalità.

    5. Condizioni del Mercato: Le divergenze nelle condizioni del mercato, come il trend o la fase di range, possono influenzare i risultati. Ad esempio, gli indicatori stocastici tendono a funzionare meglio in mercati in range piuttosto che in forti trend.

    6. Impatto delle Notizie: Le notizie economiche e gli eventi possono avere un impatto maggiore su GBPUSD rispetto a EURUSD. Sviluppi politici e decisioni delle banche centrali possono causare movimenti imprevisti.

    Per migliorare la performance su GBPUSD, potresti considerare di:

    • Ottimizzare gli Indicatori: Regolare i parametri dello stocastico, come i periodi di lookback o i livelli di soglia, per adattarli alla volatilità di GBPUSD.
    • Analisi Tecnica: Usare un'analisi tecnica aggiuntiva per filtrare i segnali o impostare stop loss e take profit in modi che riflettono meglio il comportamento di prezzo di GBPUSD.
    • Gestione del Rischio: Rivedere la tua strategia di gestione del rischio, come la dimensione delle posizioni, per adattarsi alla maggiore volatilità.
    • Backtesting: Effettuare backtest con dati storici di GBPUSD per identificare i migliori settaggi per questa coppia.
    • Strategia Adattiva: Adattare dinamicamente la tua strategia in base alle condizioni del mercato correnti.

    È importante ricordare che non esiste un'unica strategia di trading che funzioni perfettamente in ogni mercato e sotto ogni condizione. L'ottimizzazione e l'adattamento continuo della strategia per soddisfare le specificità di ogni strumento finanziario è un aspetto fondamentale del trading algoritmico.

  67. User

    che coppie sono molto simili a EURUSD?

  68. Assistant

    Le coppie di valute nel Forex possono essere simili per diversi motivi, tra cui correlazioni economiche, profili di rischio simili o semplicemente perché condividono una valuta comune. Alcune coppie che potrebbero avere un comportamento simile a EURUSD includono:

    1. AUDUSD (Dollaro australiano/US Dollaro): Come l'EURUSD, AUDUSD spesso si muove in maniera opposta rispetto al dollaro americano e può essere influenzata da fattori simili.

    2. NZDUSD (Dollaro neozelandese/US Dollaro): Questa coppia presenta un comportamento simile ad AUDUSD e quindi anche a EURUSD, a causa della sua correlazione con il movimento del dollaro americano.

    3. GBPUSD (Sterlina britannica/US Dollaro): Nonostante sia stata menzionata come una coppia problematica per la tua strategia, GBPUSD in alcuni casi può muoversi in maniera simile a EURUSD. Tuttavia, GBPUSD tende ad essere più volatile a causa delle notizie economiche e politiche specifiche del Regno Unito.

    4. USDCAD (US Dollaro/Dollaro canadese): Anche se questa coppia ha l'USD come base e non come controvaluta come EURUSD, in alcuni casi può avere comportamenti simili a EURUSD, soprattutto quando sono coinvolti movimenti di forza o debolezza del dollaro americano.

    5. USDCHF (US Dollaro/Franco svizzero): USDCHF spesso mostra una relazione inversa con EURUSD. Tuttavia, durante periodi di incertezza di mercato o avversione al rischio, entrambe possono comportarsi in modo simile con un rafforzamento dell'USD.

    Ricorda che mentre queste coppie possono avere similitudini con EURUSD, ciascuna ha le proprie peculiarità che possono causare diversi andamenti del prezzo. Ad esempio, AUDUSD e NZDUSD possono essere fortemente influenzate dai prezzi delle materie prime, mentre USDCAD può essere influenzato dall'andamento del mercato petrolifero.

    Le correlazioni nel forex possono anche cambiare nel tempo a causa di cambiamenti nei mercati globali e nelle politiche economiche. È importante fare analisi regolari sulle correlazioni e testare le strategie su diverse coppie per vedere come si comportano prima di applicare in modo estensivo.

  69. User

    perchè audusd è influenzato dalle materie prime?

  70. Assistant

    AUDUSD, noto anche come "Aussie", è influenzato dai prezzi delle materie prime perché l'economia australiana è fortemente dipendente dalle sue esportazioni di risorse naturali. L'Australia è un importante esportatore mondiale di materie prime come il carbone, il ferro, l'oro e altri metalli preziosi, nonché di vari prodotti agricoli.

    Quando i prezzi delle materie prime sono alti, è probabile che aumenti il valore delle esportazioni australiane. Ciò può portare a un surplus commerciale, che spesso si traduce in un rafforzamento del dollaro australiano (AUD) rispetto ad altre valute, compreso il dollaro statunitense (USD). Al contrario, un calo del prezzo delle materie prime potrebbe portare a un deficit commerciale e di conseguenza a un indebolimento dell'AUD.

    Alcune delle ragioni di questa correlazione includono:

    1. Bilancia Commerciale: Un paese che esporta più di quanto importa può avere una bilancia commerciale positiva, il che tendenzialmente rafforza la sua valuta.

    2. Flussi di Capitale: Gli investitori tendono ad investire in paesi con economie forti. Quando i prezzi delle materie prime sono alti, gli investitori possono essere attratti da economie basate sulle risorse come l'Australia, fornendo un flusso in entrata di capitali che rafforza l'AUD.

    3. Percezioni del Mercato: Gli operatori di mercato spesso reagiscono alle variazioni dei prezzi delle materie prime, influenzando le valute delle nazioni esportatrici attraverso la compravendita attiva.

    4. Politiche Economiche: Le entrate governative possono aumentare quando i prezzi delle materie prime sono alti, consentendo al governo di spendere di più o di ridurre le tasse, stimolando l'economia.

    5. Inflazione: Le materie prime influenzano anche l'inflazione, uno dei principali indicatori considerati dalle banche centrali per decidere sulla politica monetaria. Un aumento dei prezzi delle materie prime può portare all'inflazione, che può spingere una banca centrale a incrementare i tassi di interesse, rafforzando potenzialmente la valuta nazionale.

    Poiché l'Australia ha una così grande varietà e quantità di risorse naturali che esporta, il dollaro australiano è considerato da molti una "valuta delle materie prime" e pertanto è fortemente influenzato dal mercato globale delle materie prime.

  71. User

    c'è un problema nel codice che hai scritto. non apre posizioni di sell. ecco il codice completo: //±-----------------------------------------------------------------+ //| SpudFrye Method EA v001.mq4 | //| Copyright © 2024, G.Bassi | //±-----------------------------------------------------------------+ #include <stdlib.mqh> #include <stderror.mqh>

    // Dichiarazione delle variabili esterne extern double Lots = 1; // Dimensione del lotto standard

    // Controllo del profitto extern double StopLoss = 150; // Massimo pip disposti a perdere per posizione extern bool UseTrailingStop = true; // Se utilizzare Trailing Stop extern int TrailingStopType = 2; // Tipo di Trailing Stop (1 immediato, 2 attesa) extern double TrailingStop = 25; // Numero di pips per il trailing stop extern bool UseTakeProfit = true; // Se utilizzare Take Profit extern int TakeProfit = 300; // Massimo livello di profitto raggiungibile extern int Slippage = 3; // Slittamento possibile

    bool h4ConditionMet = false;

    // Intestazioni di etichettatura trade string label = "== scegli 15, 30, 60, 240 (4 ore) per timeframe di uscita"; extern int exittimeframe = 30; // Timeframe di uscita

    // Variabili interne bool isTradeOpened = false; // Variabile per tenere traccia se abbiamo già aperto un trade per il segnale corrente

    double lowlimit = 20; double highlimit = 80; double myStopLoss;
    double lotMM; int MagicNumber; string setup = "";

    // Riprova impostazioni int totalTries = 5; int retryDelay = 1000;

    // Debugging bool Debug=false;

    //±-----------------------------------------------------------------+ //| Funzione di init() | //±-----------------------------------------------------------------+ int init() { MagicNumber = 5000 + Symbol2Val(Symbol()) * 100 + TimeFrame_Const2Val(Period()); setup = "Stoch 5 EA " + Symbol() + "_" + TimeFrame_Val2String(TimeFrame_Const2Val(Period())); return(0); }

    //±-----------------------------------------------------------------+ //| Funzione di deinit() | //±-----------------------------------------------------------------+ int deinit() { // Qui potresti implementare la pulizia delle risorse se necessario return(0); }

    //NormalizeDouble double NormalizePrice(double price) { return(NormalizeDouble(price, Digits)); }

    double GetMinStopLoss(double price, bool isBuy) { double minStopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * Point; if (isBuy) { // Per ordini di acquisto, lo stop loss non può essere inferiore al prezzo corrente più il minStopLevel return(NormalizePrice(price + minStopLevel)); } else { // Per ordini di vendita, lo stop loss non può essere maggiore del prezzo corrente meno il minStopLevel return(NormalizePrice(price - minStopLevel)); } }

    //±-----------------------------------------------------------------+ //| Controlla le posizioni aperte | //±-----------------------------------------------------------------+ int CheckOpenPositions() { int NumBuyTrades = 0, NumSellTrades = 0; for (int i = 0; i < OrdersTotal(); i++) { if (!OrderSelect(i, SELECT_BY_POS, MODE_TRADES) || OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber) continue;

      if (OrderType() == OP_BUY) NumBuyTrades++;
      if (OrderType() == OP_SELL) NumSellTrades++;
    

    } return (NumBuyTrades + NumSellTrades); }

    //±-----------------------------------------------------------------+ //| Funzione start() | //±-----------------------------------------------------------------+ int start() { // Gestisce il trailing stop e chiude gli ordini se necessario. BeginHandleStopLoss();

    // Si assicura che vengano gestiti solo gli eventi quando una nuova barra appare nel timeframe corrente.
    if(NewBar()) {
        // Aggiorna il flag di trading e gestisce le condizioni di uscita delle posizioni.
        HandleOpenPositions();
    
        // Controlla se H4 ha emesso un segnale e non ci sono posizioni aperte.
        if(!h4ConditionMet && CheckOpenPositions() == 0) {
            // Verifica se ci sono nuove condizioni di trading da parte dello stocastico.
            if(BuySignal()) {
                h4ConditionMet = true; // Imposta il flag perché stiamo per aprire una posizione basata su questo segnale.
                OpenBuyOrder();
            } else if(SellSignal()) {
                h4ConditionMet = true; // Imposta il flag perché stiamo per aprire una posizione basata su questo segnale.
                OpenSellOrder();
            }
        }
    }
    
    // Resetta h4ConditionMet all’inizio di una nuova barra H4 se nessun trade è aperto.
    // Questo reset non sembra essere necessario nel contesto di questo codice, 
    // a meno che non ci siano altre condizioni esterne o una logica separata 
    // che chiude i trades indipendentemente da NewBar().
    // Se fosse necessario resettare h4ConditionMet in altri casi, si dovrebbe aggiungere qui la logica corretta.
    
    return(0); // Termina la funzione.
    

    }

    //±-----------------------------------------------------------------+ //| Delinea se c’è una nuova barra | //±-----------------------------------------------------------------+ bool NewBar() { static datetime lastBarTime = 0; if (Time[0] != lastBarTime) { lastBarTime = Time[0]; return(true); } else { return(false); } }

    //±-----------------------------------------------------------------+ //| Gestisce il trailing stop per tutte le posizioni | //±-----------------------------------------------------------------+ int BeginHandleStopLoss() { for (int cnt = OrdersTotal() - 1; cnt >= 0; cnt--) { if (!OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES)) continue; if (OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber) continue;

      if (OrderType() == OP_BUY || OrderType() == OP_SELL) {
         if (UseTrailingStop) {
            HandleTrailingStop(OrderType(),OrderTicket(),OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit());
         }
      }
    

    } return(0); }

    //±-----------------------------------------------------------------+ //| Segnale di acquisto tramite analisi dello stocastico | //±-----------------------------------------------------------------+ bool BuySignal() { if (StochOpen("Long")) return(true); return(false);
    }

    //±-----------------------------------------------------------------+ //| Segnale di vendita tramite analisi dello stocastico | //±-----------------------------------------------------------------+ bool SellSignal() { if (StochOpen("Short")) return(true); return(false);
    }

    //±-----------------------------------------------------------------+ //| Apertura di un ordine di acquisto | //±-----------------------------------------------------------------+ void OpenBuyOrder() { // Se è già stato aperto un trade, non fare nulla if (isTradeOpened) return;

    double ask = MarketInfo(Symbol(), MODE_ASK);
    double slippagePoints = Slippage * Point;
    double stopBuffer = 2 * MarketInfo(Symbol(), MODE_STOPLEVEL) * Point; // Buffer di sicurezza aggiuntivo
    double myStopLoss = ask - StopLoss * Point - stopBuffer;
    
    myStopLoss = NormalizeDouble(myStopLoss, Digits);
    
    double myTakeProfit = 0;
    if (UseTakeProfit && TakeProfit > 0) {
        myTakeProfit = ask + TakeProfit * Point;
        myTakeProfit = NormalizeDouble(myTakeProfit, Digits);
    }
    
    int ticket = OrderSend(Symbol(), OP_BUY, Lots, NormalizeDouble(ask, Digits), slippagePoints, myStopLoss, myTakeProfit, setup, MagicNumber, 0, clrGreen);
    if (ticket < 0) {
        Print("Error Opening BUY Order: ", GetLastError());
    } 
    // Se OrderSend ha esito positivo e ritorna un ticket valido:
    if(ticket > 0) {
        isTradeOpened = true;
    }
    // Se OrderSend ha esito positivo e ritorna un ticket valido:
    if(ticket > 0) {
        isTradeOpened = true;
    }
    

    }

    void OpenSellOrder() { // Se è già stato aperto un trade, non fare nulla if (isTradeOpened) return;

    double bid = MarketInfo(Symbol(), MODE_BID);
    double slippagePoints = Slippage * Point;
    double stopBuffer = 2 * MarketInfo(Symbol(), MODE_STOPLEVEL) * Point; // Buffer di sicurezza aggiuntivo
    double myStopLoss = bid + StopLoss * Point + stopBuffer;
    
    myStopLoss = NormalizeDouble(myStopLoss, Digits);
    
    double myTakeProfit = 0;
    if (UseTakeProfit && TakeProfit > 0) {
        myTakeProfit = bid - TakeProfit * Point;
        myTakeProfit = NormalizeDouble(myTakeProfit, Digits);
    }
    
    int ticket = OrderSend(Symbol(), OP_SELL, Lots, NormalizeDouble(bid, Digits), slippagePoints, myStopLoss, myTakeProfit, setup, MagicNumber, 0, clrRed);
    if (ticket < 0) {
        Print("Error Opening SELL Order: ", GetLastError());
    } 
    

    }

    //±-----------------------------------------------------------------+ //| Analisi Stocastica per i segnali di apertura ordini | //±-----------------------------------------------------------------+ bool stochOpenCondition = false; // Aggiunta al blocco delle variabili globali datetime last4HBarTime;

    bool StochOpen(string signal) { // Controllo iniziale se siamo all’inizio della nuova candela H4 e reset del segnale se necessario datetime current4HBarTime = iTime(Symbol(), PERIOD_H4, 0); if (last4HBarTime != current4HBarTime) { last4HBarTime = current4HBarTime; if (stochOpenCondition) { stochOpenCondition = false; // Reset della condizione all’inizio di una nuova barra H4 se il segnale era stato precedentemente impostato return true; // Se la condizione era vera alla chiusura della precedente candela H4, restituiamo true per aprire un trade } }

    double main_15 = iStochastic(NULL, PERIOD_M15, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0); double main_30 = iStochastic(NULL, PERIOD_M30, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0); double main_1H = iStochastic(NULL, PERIOD_H1, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0); double main_4H = iStochastic(NULL, PERIOD_H4, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0); double main_4Hlast = iStochastic(NULL, PERIOD_H4, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);

    // Verifica delle condizioni senza cambiare alcuna azione fino alla nuova barra H4 if (signal == "Long" && main_4H > lowlimit && main_4Hlast < lowlimit && main_15 > lowlimit && main_30 > lowlimit && main_1H > lowlimit) { stochOpenCondition = true; // Impostazione del segnale al verificarsi della condizione } else if (signal == "Short" && main_4H < highlimit && main_4Hlast > highlimit && main_15 < highlimit && main_30 < highlimit && main_1H < highlimit) { stochOpenCondition = true; // Impostazione del segnale al verificarsi della condizione }

    return false; // Nessuna azione intrapresa fino alla chiusura della barra H4 corrente }

    //±-----------------------------------------------------------------+ //| Rileva la nuova barra del timeframe H4 | //±-----------------------------------------------------------------+ bool NewBarH4() { static datetime lastBarTimeH4 = 0; datetime currentTimeH4 = iTime(Symbol(), PERIOD_H4, 0); if (currentTimeH4 != lastBarTimeH4) { lastBarTimeH4 = currentTimeH4; return true; } else { return false; } } //±-----------------------------------------------------------------+ //| Gestione delle posizioni aperte | //±-----------------------------------------------------------------+ int HandleOpenPositions() { int totalOpened = CheckOpenPositions(); if (totalOpened == 0) { isTradeOpened = false; h4ConditionMet = false; // Potresti aver bisogno di resettare anche questa se chiudi manualmente } for (int cnt = OrdersTotal() - 1; cnt >= 0; cnt--) { if (!OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES)) continue; if (OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber) continue;

      if (OrderType() == OP_BUY) {
          // Qui potrebbe andare la logica di uscita per il BUY se necessaria
      } else if (OrderType() == OP_SELL) {
          // E qui quella di uscita per il SELL se necessaria
      }
    

    } return(0); }

    //±-----------------------------------------------------------------+ //| Trailing stop effettivo per una posizione | //±-----------------------------------------------------------------+ void HandleTrailingStop(int tradeType, int ticket, double openPrice, double currentStop, double currentTP) { double point = MarketInfo(Symbol(), MODE_POINT); double newStop;

    if (tradeType == OP_BUY) { double buyTrailStopLevel = openPrice + TrailingStop * point; if (Bid >= buyTrailStopLevel) { newStop = Bid - TrailingStop * point; newStop = NormalizeDouble(newStop, Digits); if (newStop != currentStop) { OrderModify(ticket, openPrice, newStop, currentTP, 0, clrNONE); if (Debug) Print("Modificato il Trailing Stop BUY per il ticket ", ticket); } } } else if (tradeType == OP_SELL) { double sellTrailStopLevel = openPrice - TrailingStop * point; if (Ask <= sellTrailStopLevel) { newStop = Ask + TrailingStop * point; newStop = NormalizeDouble(newStop, Digits); if (newStop != currentStop) { OrderModify(ticket, openPrice, newStop, currentTP, 0, clrNONE); if (Debug) Print("Modificato il Trailing Stop SELL per il ticket ", ticket); } } } }

    //±-----------------------------------------------------------------+ //| Verifica che lo stop loss sia valido e lo normalizza | //±-----------------------------------------------------------------+ double ValidStopLoss(int tradeType, double proposedStop) { double minStopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * MarketInfo(Symbol(), MODE_POINT);

    // Ajusta lo stop loss proposto a seconda se è BUY o SELL if (tradeType == OP_BUY && proposedStop < Ask - minStopLevel) { return (Ask - minStopLevel); } else if (tradeType == OP_SELL && proposedStop > Bid + minStopLevel) { return (Bid + minStopLevel); } return(proposedStop); } //±-----------------------------------------------------------------+ //| Indicatori ausiliari | //±-----------------------------------------------------------------+ int TimeFrame_Const2Val(int Constant) { switch(Constant) { case 1:
    return(1); case 5:
    return(2); case 15: return(3); case 30: return(4); case 60: return(5); case 240: return(6); case 1440: return(7); case 10080: return(8); case 43200: return(9); default: return(-1); // Valore di default se nessun caso è stato abbinato } } //+------------------------------------------------------------------+ //| Time frame string appropriation function | //+------------------------------------------------------------------+ string TimeFrame_Val2String(int Value ) { switch(Value) { case 1:
    return("PERIOD_M1"); case 2:
    return("PERIOD_M5"); case 3: return("PERIOD_M15"); case 4: return("PERIOD_M30"); case 5: return("PERIOD_H1"); case 6: return("PERIOD_H4"); case 7: return("PERIOD_D1"); case 8: return("PERIOD_W1"); case 9: return("PERIOD_MN1"); default: return("undefined " + Value); } } int Symbol2Val(string symbol) { string mySymbol = StringSubstr(symbol,0,6); if(mySymbol=="AUDCAD") return(1); if(mySymbol=="AUDJPY") return(2); if(mySymbol=="AUDNZD") return(3); if(mySymbol=="AUDUSD") return(4); if(mySymbol=="CHFJPY") return(5); if(mySymbol=="EURAUD") return(6); if(mySymbol=="EURCAD") return(7); if(mySymbol=="EURCHF") return(8); if(mySymbol=="EURGBP") return(9); if(mySymbol=="EURJPY") return(10); if(mySymbol=="EURUSD") return(11); if(mySymbol=="GBPCHF") return(12); if(mySymbol=="GBPJPY") return(13); if(mySymbol=="GBPUSD") return(14); if(mySymbol=="NZDUSD") return(15); if(mySymbol=="USDCAD") return(16); if(mySymbol=="USDCHF") return(17); if(mySymbol=="USDJPY") return(18); return(19); }

    cosa correggo?

  72. Assistant

    La logica per la funzione StochOpen deve essere corretta per assicurarsi che vengano generati correttamente sia i segnali di acquisto (Long) che di vendita (Short). Dalle informazioni che hai fornito, sembra che il problema possa risiedere nel modo in cui la condizione è verificata e nel momento in cui la variabile h4ConditionMet viene impostata. Inoltre, sarà importante assicurarsi che non ci siano altri errori logici nel codice dell'EA che potrebbero causare il malfunzionamento.

    Proviamo a riscrivere la funzione StochOpen per assicurarsi che venga generato un segnale di vendita (Short) quando le condizioni sono soddisfatte:

    bool StochOpen(string signal) {
       double main_15 = iStochastic(NULL, PERIOD_M15, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
       double main_30 = iStochastic(NULL, PERIOD_M30, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
       double main_1H = iStochastic(NULL, PERIOD_H1, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
       double main_4H = iStochastic(NULL, PERIOD_H4, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
       double main_4Hlast = iStochastic(NULL, PERIOD_H4, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 2);
    
       if (signal == "Long" &&
           main_4H > lowlimit && main_4Hlast < lowlimit &&
           main_15 > lowlimit && main_30 > lowlimit && main_1H > lowlimit) {
           if (!h4ConditionMet) {
               h4ConditionMet = true;
               return true;
           }
           return false;
       } else if (signal == "Short" &&
                  main_4H < highlimit && main_4Hlast > highlimit &&
                  main_15 < highlimit && main_30 < highlimit && main_1H < highlimit) {
           if (!h4ConditionMet) {
               h4ConditionMet = true;
               return true;
           }
           return false;
       }
    
       // Alla chiusura di una barra H4 senza soddisfare la condizione si resetta h4ConditionMet
       if (signal == "Long" && main_4Hlast >= lowlimit || signal == "Short" && main_4Hlast <= highlimit) {
           h4ConditionMet = false;
       }
    
       return false;
    }
    

    Nella funzione start(), dovresti usare una sola chiamata di StochOpen e basare la tua decisione di aprire un ordine di acquisto o di vendita unicamente su quella chiamata:

    int start() {
        BeginHandleStopLoss();
    
        if (NewBar()) {
            HandleOpenPositions();
    
            if(CheckOpenPositions() == 0) {
                if(h4ConditionMet && BuySignal()) {
                    OpenBuyOrder();
                    h4ConditionMet = false; // Reset condizione dopo aver aperto l'ordine
                } else if(h4ConditionMet && SellSignal()) {
                    OpenSellOrder();
                    h4ConditionMet = false; // Reset condizione dopo aver aperto l'ordine
                }
            }
        }
    
        return(0);
    }
    

    Con questi aggiornamenti, una volta che il segnale H4 viene generato (e quindi h4ConditionMet è impostato su true), l'EA controllerà le condizioni per un segnale di acquisto o di vendita. Se le condizioni di acquisto o di vendita sono soddisfatte, l'EA tenterà di aprire un ordine di acquisto o di vendita e resetterà h4ConditionMet in modo che non possa aprire più ordini fino al prossimo segnale valido H4.

    Si raccomanda di testare nuovamente l'EA in un ambiente di simulazione per assicurarsi che i cambiamenti abbiano risolto il problema prima di fare trading con denaro reale.

  73. User

    così non apre nessuna posizione.

  74. Assistant

    Ho notato un errore nella logica della funzione StochOpen che potrebbe essere il motivo per cui non vengono aperte posizioni short. L'errore si trova nella condizione di reset della variabile h4ConditionMet, che viene resettata quando non dovrebbe. Inoltre, se il segnale H4 è stato già rilevato, non dovremmo cercare ulteriori segnali fino a quando non viene rilevato un nuovo segnale H4.

    Ecco come correggiamo questo nella funzione StochOpen:

    bool StochOpen(string signal) {
       static datetime lastH4Time = 0; // Variabile per tracciare l'ultima esecuzione su H4
       datetime currentH4Time = iTime(Symbol(), PERIOD_H4, 0); // Ora corrente della barra H4
       
       // Controlla se siamo ad una nuova barra H4
       if (lastH4Time != currentH4Time) {
           lastH4Time = currentH4Time; // Aggiorna l'ultimo momento di controllo su H4
           h4ConditionMet = false; // Resetta la variabile di condizione a false a ogni nuova barra H4
       }
    
       // ... (Logica per ottenere i valori dello Stochastic rimane invariata) ...
    
       if (!h4ConditionMet) {
           if (signal == "Long" &&
               main_4H > lowlimit && main_4Hlast < lowlimit &&
               main_15 > lowlimit && main_30 > lowlimit && main_1H > lowlimit) {
               h4ConditionMet = true;
               return true;
           } else if (signal == "Short" &&
                      main_4H < highlimit && main_4Hlast > highlimit &&
                      main_15 < highlimit && main_30 < highlimit && main_1H < highlimit) {
               h4ConditionMet = true;
               return true;
           }
       }
    
       return false;
    }
    

    Con questa correzione, h4ConditionMet viene impostato a true solo se è la prima volta che rileviamo la condizione in una specifica barra H4. Una volta rilevata la condizione, il flag rimarrà true fino all'inizio della barra H4 successiva.

    Nella funzione start, dovresti poi effettuare il controllo dei segnali come segue:

    int start() {
        BeginHandleStopLoss();
    
        if (NewBar()) {
            HandleOpenPositions();
    
            if(CheckOpenPositions() == 0) {
                if(h4ConditionMet && BuySignal()) {
                    OpenBuyOrder();
                } else if(h4ConditionMet && SellSignal()) {
                    OpenSellOrder();
                }
            }
        }
    
        return(0);
    }
    

    Nota che non abbiamo più bisogno di resettare h4ConditionMet dopo l'apertura di un ordine, perché abbiamo già un appropriato controllo temporale in StochOpen che assicura che il segnale rimanga valido fino all'inizio della barra H4 successiva.

    Infine, BuySignal e SellSignal dovrebbero essere due funzioni separate che restituiscono true o false a seconda del segnale rilevato da StochOpen rispetto a quelle specifiche condizioni, e quindi la funzione StochOpen dovrebbe essere chiamata una sola volta con l'argomento corretto ("Long" o "Short") basandosi sull'analisi del mercato da effettuare prima della chiamata di StochOpen.

    I suggerimenti includono:

    1. Controlla se le funzioni BuySignal e SellSignal stanno lavorando come atteso:

      bool BuySignal() {
          return StochOpen("Long");
      }
      
      bool SellSignal() {
          return StochOpen("Short");
      }
      

      Assicurati che le chiamate a StochOpen passino il segnale corretto ("Long" o "Short").

    2. Assicurati che la variabile h4ConditionMet sia visibile a tutte le funzioni che ne necessitano. Se la dichiarazione è esterna (come nel tuo codice originale), non devi dichiararla nuovamente all'interno della funzione StochOpen.

    3. Testa il codice dopo ogni modifica usando lo Strategy Tester in MT4, con attenzione ai segnali di vendita e d'acquisto e ai relativi ingressi nel mercato.

    4. Verifica anche che tutti i parametri degli indicatori siano corretti e che non vi siano errori logici in altre parti del tuo EA non mostrate qui.

  75. User

    riscrivi per intero bool StochOpen

  76. Assistant

    Ecco la funzione StochOpen completa, riscritta con la logica corretta per rilevare i segnali di acquisto e di vendita in base all'allineamento degli stocastici, prendendo azioni solo alla chiusura della barra H4:

    //+------------------------------------------------------------------+
    //| Rileva i segnali stocastici                                      |
    //+------------------------------------------------------------------+
    bool StochOpen(string signal) {
        static datetime lastH4BarTime = 0; // Memorizza l'ultimo aggiornamento per il periodo H4
        datetime currentH4BarTime = iTime(Symbol(), PERIOD_H4, 0); // Orario corrente della barra H4
        
        double main_15 = iStochastic(NULL, PERIOD_M15, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
        double main_30 = iStochastic(NULL, PERIOD_M30, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
        double main_1H = iStochastic(NULL, PERIOD_H1, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
        double main_4H = iStochastic(NULL, PERIOD_H4, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);
        double main_4Hlast = iStochastic(NULL, PERIOD_H4, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
    
        // Controlla se ci troviamo in una nuova barra H4
        if(currentH4BarTime != lastH4BarTime) {
            lastH4BarTime = currentH4BarTime; // Aggiornamento del tempo di controllo
            h4ConditionMet = false; // Resetta la condizione per il nuovo controllo H4
        }
    
        if(h4ConditionMet) {
            // Se h4ConditionMet è già vero, significa che abbiamo già identificato un segnale
            // e quindi non dobbiamo cercare altri segnali fino alla fine della barra H4 corrente
            return false;
        }
    
        // Rileva il segnale per un'operazione Long
        if(signal == "Long" && main_4Hlast < lowlimit && main_4H >= lowlimit) {
            // Controlla se gli altri timeframe concordano per il segnale Long
            if(main_15 >= lowlimit && main_30 >= lowlimit && main_1H >= lowlimit) {
                h4ConditionMet = true; // Segna che un segnale valido è stato trovato
                return true;
            }
        }
    
        // Rileva il segnale per un'operazione Short
        else if(signal == "Short" && main_4Hlast > highlimit && main_4H <= highlimit) {
            // Controlla se gli altri timeframe concordano per il segnale Short
            if(main_15 <= highlimit && main_30 <= highlimit && main_1H <= highlimit) {
                h4ConditionMet = true; // Segna che un segnale valido è stato trovato
                return true;
            }
        }
    
        return false; // Nessun segnale è stato trovato
    }
    

    Ricorda che questa funzione dovrebbe essere chiamata una sola volta per ogni barra di M15, e soltanto se non ci sono posizioni aperte—cioè CheckOpenPositions() è zero. Inoltre, la funzione StochOpen ora imposta la variabile h4ConditionMet al primo segnale corretto in una nuova barra di H4 e non cerca altri segnali fino alla nuova barra di H4, evitando così ingressi multipli sullo stesso segnale.

    Dovresti modificare adeguatamente la funzione start per riflettere queste condizioni. Si consiglia inoltre di eseguire ampi test e backtest nell'ambiente di demo per assicurarsi della correttezza della logica e della robustezza dell'EA prima di utilizzarlo in un ambiente di trading live.