Trading Sistematico

Guida all'Utilizzo dell'EA per Chiusura Ordini e Trailing su MetaTrader 5
MetaTrader5
Guida all'Utilizzo dell'EA per Chiusura Ordini e Trailing su MetaTrader 5

Se sei un trader che utilizza MetaTrader 5, oggi voglio parlarti di un Expert Advisor (EA) davvero interessante che può semplificarti la vita. Si tratta di una modifica di un vecchio EA, pensata per rendere la gestione degli ordini ancora più intuitiva. Come utilizzarlo: Aggiungi questo EA su qualsiasi simbolo di tuo interesse. Imposta i valori delle variabili che desideri per il Take Profit (TP), Stop Loss (SL), Trailing e la soglia di profitto o perdita per gli ordini. Questo EA non è basato su un numero magico specifico, quindi se inserisci un ordine da un dispositivo mobile, l'EA si occuperà di modificarlo (SL, TP e Trailing). Le caratteristiche di modifica includono: Un'interfaccia con 5 pulsanti separati. Chiusura automatica di tutti gli ordini se si raggiunge il profitto, in base al parametro: "CLOSE IF PROFIT-xxxx" (imposta a 0 se non vuoi utilizzare questa funzione). Ad esempio, impostando 100.0 chiuderai automaticamente tutti gli ordini quando il profitto raggiunge 100€. Se invece imposti 0.0, questa funzione sarà disattivata. Chiusura automatica di tutti gli ordini se si raggiunge la perdita, in base al parametro: "CLOSE IF LOSS-xxxx" (imposta a 0 se non vuoi utilizzare questa funzione). Ad esempio, impostando -70.0, chiuderai automaticamente tutti gli ordini quando la perdita raggiunge -70€. Se invece imposti 0.0, anche questa funzione sarà disattivata. Buon trading a tutti! Storico Aggiornamenti: Aggiunto pulsante per chiudere gli ordini BUY. Aggiunto pulsante per chiudere gli ordini SELL. Rimosso il parametro non utilizzato "Lots".

2024.04.21
QuickTradeKeys123: Il Tuo Alleato per MetaTrader 5
MetaTrader5
QuickTradeKeys123: Il Tuo Alleato per MetaTrader 5

Se sei un trader che cerca di migliorare la propria esperienza su MetaTrader 5, non puoi perderti il QuickTradeKeys 123. Questo EA (Expert Advisor) è stato progettato per rispondere rapidamente e in modo efficiente alle dinamiche di mercato. Con un semplice tocco di tasto, puoi effettuare operazioni direttamente dalla vista grafico. Ecco un riepilogo delle sue funzionalità: Funzionalità Principali Tasto '1': Apre una posizione long con una dimensione di lotto predefinita. Tasto '2': Apre una posizione short con una dimensione di lotto predefinita. Tasto '3': Chiude tutte le posizioni aperte dall'EA in base al numero magico specificato. Questo EA è semplice da utilizzare e si adatta sia ai principianti che ai trader esperti che cercano un controllo immediato delle operazioni tramite la tastiera. Ambito di Applicazione Il QuickTradeKeys 123 è compatibile con tutte le coppie di valute e timeframe. Per ottenere prestazioni ottimali e un'esecuzione rapida, è consigliabile utilizzare un broker con uno spread ridotto e un accesso al mercato fluido. Installazione Per installare l'EA, basta trascinarlo sul grafico desiderato, assicurarsi che il trading automatico sia abilitato in MetaTrader e che l'EA sia autorizzato ad eseguire operazioni. Configura il numero magico secondo le tue necessità nelle impostazioni di input. Importante Ricorda, questo EA non è destinato all'uso su un conto di trading reale a meno che tu non comprenda appieno il concetto sottostante e i rischi associati. È fortemente consigliato testare prima l'EA su un conto demo per familiarizzare con il suo comportamento.

2024.04.20
Come Contare e Passare nel Codice di MetaTrader 5
MetaTrader5
Come Contare e Passare nel Codice di MetaTrader 5

01. Contare "X" Volte e poi Passare. Passo 01 - Crea una variabile per impostare il limite di conteggio. Puoi usarla come parametro di input e per ottimizzare il tuo codice. Passo 02 - Crea un'altra variabile per memorizzare il limite conteggiato (quante volte è stato conteggiato). Passo 03 - Una volta che il Contatore e il tuo limite di conteggio sono uguali, significa che è tempo di passare al blocco di codice specificato da te. Passo 04 - Una volta che il codice è passato, assicurati di azzerare il contatore anche. Altrimenti, continuerà a contare all'infinito (in questo caso). Puoi impostare condizioni di filtraggio per il blocco del Contatore. Ad esempio, >> "SE questo è vero, allora conta una volta." input int count = 50; // Imposta il limite di conteggio come input int Counter; // variabile contatore // Inizializzazione Esperto -------------------- int OnInit() { return(INIT_SUCCEEDED); } // De-inizializzazione Esperto ------------------- void OnDeinit(const int reason) { } // OnTick Esperto -------------------------- void OnTick() { Counter ++; // aggiungi 1 al contatore ad ogni tick. Comment("Conteggio Attuale -:", Counter); if(Counter == count) // Conta "X" volte e passa | Questo blocco viene eseguito solo una volta per ogni conteggio. {      // Il tuo codice va qui...... Alert(count," Volte conteggiato"); Counter = 0; // Ripristina il contatore alla fine del tuo blocco di codice. Questo è fondamentale. } } // Fine di OnTick  <<---------------------- 02. Passare "X" Volte e poi Aspettare "X" Volte. Questo metodo può essere utilizzato come aspettare e passare, passare e aspettare. Passo 01 - Crea una variabile per impostare il limite di conteggio e il limite di attesa. Puoi usarli come parametri di input e per ottimizzare il tuo codice. Passo 02 - Crea un'altra variabile per memorizzare i limiti di conteggio e attesa (quante volte è stato conteggiato e atteso). Passo 03 - Una volta che il Contatore e il tuo limite di conteggio sono uguali, significa che è tempo di passare al blocco di codice specificato da te. Passo 04 - Una volta che il limite di attesa è raggiunto, assicurati di azzerare il contatore e il limite di attesa anche. Altrimenti, smetterà di funzionare (in questo caso). Puoi impostare condizioni di filtraggio per i blocchi del Contatore e del Limite di Attesa. Ad esempio, >> "SE questo è vero, aspetta un po'" input int count = 50; // Imposta il limite di conteggio come input input int wait = 50; // Imposta il limite di attesa come input int Counter; // variabile contatore valore predefinito è "0" int Waiter; // variabile di attesa valore predefinito è "0" // Inizializzazione Esperto -------------------- int OnInit()   {    return(INIT_SUCCEEDED);   } // De-inizializzazione Esperto ------------------- void OnDeinit(const int reason)   {   } // OnTick Esperto -------------------------- void OnTick()   {    Comment("Conteggio Tick -: ", Counter, "\n", "Tick Attesi -: ", Waiter);    if(Counter < count) // Passa "X" volte      {       Counter++; // aggiorna il contatore       // Il tuo codice va qui.      }    else       if(Waiter < wait) // Aspetta per "X" volte         {          Waiter++; // aggiorna il limite di attesa          // Il tuo codice va qui.         }    if(Waiter == wait) // Il limite di attesa è stato raggiunto      {       Counter = 0; // ripristina il contatore       Waiter = 0; // ripristina il limite di attesa      }   } // Fine di OnTick  <<---------------------- //+------------------------------------------------------------------+ Speciale -: Puoi programmare il "Passa X volte e fermati" modificando il codice sopra rimuovendo il blocco di attesa. Così conterà per un numero specifico e smetterà di funzionare fino a quando il contatore non sarà ripristinato. Puoi ripristinarlo ovunque nel tuo codice se crei queste variabili su scala globale. (variabili globali)

2024.04.14
Rileva una Nuova Candela con il Conteggio delle Barre in MetaTrader 5
MetaTrader5
Rileva una Nuova Candela con il Conteggio delle Barre in MetaTrader 5

Nel mio precedente codice, ho utilizzato il tempo per rilevare una nuova candela. Oggi, invece, ci concentreremo sul conteggio delle barre per individuare una nuova candela. Questo metodo è molto più leggero e veloce rispetto all'approccio basato sul tempo. Vediamo insieme come implementarlo: Dichiarare le variabili con il tipo di dato intero per memorizzare il conteggio delle barre. Assegnare il conteggio delle barre alla variabile BarsTotal_OnInt durante l'inizializzazione. Utilizzare la funzione iBars(); per assegnare il conteggio delle barre alla variabile BarsTotal_OnTick nel grafico live. Questa variabile viene aggiornata ad ogni tick. Utilizzare commenti e avvisi per verificare l'accuratezza del codice. Ed ecco il codice: int BarsTotal_OnInt; int BarsTotal_OnTick; //+------------------------------------------------------------------+ //| Funzione di inizializzazione dell'Expert                                   | //+------------------------------------------------------------------+ int OnInit()   {      BarsTotal_OnInt = iBars(NULL,PERIOD_CURRENT); // Assegna il totale delle barre all'inizializzazione    return(INIT_SUCCEEDED);   }    void OnTick() // Funzione OnTick   {      BarsTotal_OnTick = iBars(NULL,PERIOD_CURRENT); // Memorizza l'ammontare più recente       if(BarsTotal_OnTick > BarsTotal_OnInt) // È arrivata una nuova candela    {     BarsTotal_OnInt = BarsTotal_OnTick; // Aggiorna la cronologia.     Alert("È arrivata una nuova candela");     Comment("Conteggio barre in cronologia -: ", BarsTotal_OnInt, "\n", "Conteggio barre in live -: ", BarsTotal_OnTick); // Il tuo codice va qui. -------------------------- // Puoi aggiornare un "flag" / variabile da utilizzare anche in seguito.    }   }

2024.04.11
Gestione Avanzata delle Operazioni con SL Virtuale e TP Pendenti in MetaTrader 4
MetaTrader4
Gestione Avanzata delle Operazioni con SL Virtuale e TP Pendenti in MetaTrader 4

Introduzione al Virtual SL TP Pending Oggi parliamo di un EA molto interessante: "Virtual_SL_TP_Pending_with_SL_Trailing.mq4". Questo strumento è progettato per gestire le operazioni impostando stop loss e take profit virtuali, oltre a un ordine pendente virtuale con la possibilità di utilizzare un trailing stop loss. Analisi dello Script Ecco una panoramica delle funzionalità principali dello script: Copyright e Link: In questa sezione troviamo le informazioni relative al copyright e un link al sito del creatore. Versione: Indica la versione attuale dello script. Descrizione: Fornisce informazioni dettagliate sullo script, compreso l'indirizzo email del creatore, i dettagli sulla proprietà intellettuale e un avviso sull'uso del software a proprio rischio. Parametri di Input: Variabili esterne che permettono agli utenti di personalizzare il comportamento dell'EA, tra cui: StopLossPoints: Stop loss iniziale in punti. TakeProfitPoints: Take profit iniziale in punti. SpreadThreshold: Soglia di spread per stop loss/take profit virtuali in punti. TrailingStopPoints: Trailing stop in punti per l'ordine pendente virtuale. EnableTrailing: Opzione per abilitare o disabilitare il trailing stop. Variabili Globali: Variabili utilizzate nello script per memorizzare spread iniziale, stop loss virtuale, take profit virtuale e prezzo dell'ordine pendente. Funzione di Inizializzazione (OnInit): Inizializza l'EA quando viene collegato a un grafico. Calcola lo stop loss virtuale iniziale, il take profit e il prezzo dell'ordine pendente in base ai parametri di input. Funzione Tick (OnTick): Viene chiamata ad ogni tick del prezzo. Controlla se lo spread è aumentato oltre la soglia e adegua di conseguenza lo stop loss virtuale, il take profit e il prezzo dell'ordine pendente. Monitora anche se il prezzo tocca lo stop loss o il take profit virtuali e chiude la posizione. Se il trailing stop è abilitato e il prezzo raggiunge il prezzo dell'ordine pendente, piazza un ordine pendente virtuale con trailing stop loss. Funzione di Chiusura Posizione (ClosePosition): Chiude la posizione quando il prezzo tocca lo stop loss o il take profit virtuali. Funzione di Piazzamento Ordine Pendenti (PlacePendingOrder): Piazza un ordine pendente virtuale con trailing stop loss se il trailing stop è abilitato. Conclusione Questo EA offre un modo flessibile per gestire le operazioni utilizzando livelli virtuali e una funzione di trailing stop, permettendo ai trader di automatizzare il processo di gestione delle operazioni su MetaTrader 4.

2024.04.10
Chiudere Posizioni con Close Basket Pairs v1 su MetaTrader 4
MetaTrader4
Chiudere Posizioni con Close Basket Pairs v1 su MetaTrader 4

Se sei un trader attivo su MetaTrader 4, sicuramente sai quanto sia importante gestire le proprie posizioni in modo efficace. Oggi voglio parlarti di uno script MQL4 davvero utile chiamato CloseBasketPairs.mq4, progettato per chiudere le posizioni su un gruppo di coppie di valute in base a soglie di profitto e perdita. Scopriamo insieme come funziona! Lo script è stato sviluppato da persinaru@gmail.com. È protetto da copyright della MetaQuotes Software Corp. nel 2024. Puoi trovare ulteriori dettagli sul sito di MetaQuotes. La versione attuale dello script è la 1.01. È concesso in licenza come open source, quindi puoi utilizzarlo liberamente. Il suo obiettivo principale è chiudere le posizioni di un paniere di coppie di valute quando vengono raggiunti determinati livelli di profitto o perdita. Attenzione: utilizza questo script a tuo rischio e pericolo; l'autore non si assume responsabilità per eventuali danni o perdite. Il funzionamento dello script è piuttosto semplice: definisce le coppie di valute nel paniere e i rispettivi tipi di ordine, insieme ai limiti di profitto e perdita. Scorre poi tutte le posizioni aperte e verifica se appartengono alle coppie di valute definite. Se una posizione supera il limite di profitto o scende oltre il limite di perdita, lo script provvede a chiuderla automaticamente. Inoltre, lo script include funzioni per l'inizializzazione, la de-inizializzazione e la gestione degli eventi tick. La funzione PrintStrategyInfo() è utile per stampare informazioni riguardo la strategia utilizzata.

2024.04.10
Strategia di Trading Trend-Following Semplice per MetaTrader 4
MetaTrader4
Strategia di Trading Trend-Following Semplice per MetaTrader 4

Se sei un trader e usi MetaTrader 4, oggi parliamo di una strategia di trading trend-following semplice che puoi implementare per comprare e vendere in base a condizioni predefinite. Vediamo insieme come funziona questo script! Struttura dello Script Inizializzazione: Quando lo script viene lanciato, si inizializza e stampa un messaggio di conferma. De-inizializzazione: Al termine dell'esecuzione, il programma si de-inizializza e stampa un messaggio di conferma. Funzione OnTick: Ogni volta che c’è un nuovo tick (cambiamento di prezzo) nel mercato, questa funzione si attiva. a. Reset delle Variabili di Posizione: Qui si azzerano le variabili che tracciano le posizioni di acquisto e vendita aperte. b. Controllo Ordini Aperti: Lo script passa in rassegna tutti gli ordini aperti per capire se ci sono posizioni attive di acquisto o vendita. c. Apri Posizione di Acquisto: Se non c'è una posizione di acquisto aperta e il flag "OpenBuyPosition" è impostato su vero, tenta di aprirne una al prezzo di offerta attuale. Viene impostato stop loss e take profit per l'ordine di acquisto. d. Apri Posizione di Vendita: Se non c'è una posizione di vendita aperta e il flag "OpenSellPosition" è attivato, lo script proverà ad aprirne una al prezzo di richiesta attuale, impostando anch'essa stop loss e take profit. e. Controlla Ordini Chiusi: Viene effettuato un controllo sugli ordini chiusi. Se un ordine di acquisto o vendita è chiuso in profitto, il flag corrispondente viene resettato. Parametri di Input: Lo script offre parametri di input per la dimensione del lotto, stop loss, take profit e flag per controllare se aprire posizioni di acquisto o vendita. Avvertenza: È presente un disclaimer che avvisa gli utenti di utilizzare lo script a proprio rischio, esonerando il creatore da qualsiasi responsabilità per danni o perdite potenziali. In sintesi, questo script è pensato per automatizzare il processo di esecuzione degli ordini di acquisto e vendita basati su una strategia di trend-following continua, permettendo agli utenti di personalizzare parametri come la dimensione del lotto e la direzione del trade. Ricorda sempre di fare attenzione e testare a fondo prima di utilizzarlo in ambienti di trading dal vivo.

2024.04.10
Implementare un Trailing Stop in MetaTrader 5: Guida Pratica per Trader
MetaTrader5
Implementare un Trailing Stop in MetaTrader 5: Guida Pratica per Trader

Questo codice funziona sia che utilizziate un Stop Loss, sia che non lo facciate. Requisiti È necessario includere "Trade.mqh" per avere accesso alla classe CTrade, che permette di lavorare con le posizioni e gli ordini. #include <Trade\Trade.mqh> // <<------------------------------------------ Includi "Trade.mqh" per accedere alla classe CTrade È necessario impostare un parametro di input per regolare la distanza del trailing come desiderate. Questo non è obbligatorio, ma è comodo. input double Trailing_Step = 3.0; È necessario definire un'istanza della classe CTrade. Il nome può essere qualsiasi. È consigliabile definirla dopo l'OnInit event handler. Poi, dovete creare un if statement per controllare se ci sono posizioni aperte al momento. Questa condizione chiama la funzione Check_TrailingStop(); ad ogni tick. Questo è fondamentale perché l'EA deve seguire il prezzo in modo preciso e fluido. Ricordate di posizionare questa condizione all'inizio dell'evento OnTick per farla funzionare correttamente. //+------------------------------------------------------------------+ //| Funzione di inizializzazione dell'Expert                                   | //+------------------------------------------------------------------+ int OnInit()   { //--- crea un timer    EventSetTimer(60); //---    return(INIT_SUCCEEDED);   } CTrade trade; // <<------------------------------------------ Dichiara la classe "CTrade". Puoi sostituire "trade" con qualsiasi nome tu voglia void OnTick()   {    if(PositionsTotal() > 0) // chiama la funzione di trailing stop per ogni tick se ci sono posizioni aperte.      {       Check_TrailingStop();      }          } Dovete dichiarare una funzione personalizzata chiamata Check_TrailingStop(); (in questo caso) per completare il resto. Potete usare qualsiasi nome desideriate. La funzione personalizzata scorre tutte le posizioni aperte e le segue alla distanza richiesta. void Check_TrailingStop()   {    int totalPositions = PositionsTotal();    for(int count =0; count < totalPositions; count++)      {       ulong TicketNo = PositionGetTicket(count); // Ottieni il numero di ticket della posizione usando l'indice della posizione.       if(PositionSelectByTicket(TicketNo)) // Seleziona una posizione usando il numero di ticket         {          if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) // Controlla il tipo di posizione.            {             double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);             double stopLoss  = PositionGetDouble(POSITION_SL);       // <<-------------------Ottieni il valore attuale dello Stop Loss             double takeProfit = PositionGetDouble(POSITION_TP);             double bidPrice  = SymbolInfoDouble(_Symbol,SYMBOL_BID);             ulong ticket = PositionGetTicket(count);             double trailingLevel = NormalizeDouble(bidPrice - (Trailing_Step * Point()),_Digits);             if(stopLoss < openPrice) // Se non esiste Stop Loss               {                if(bidPrice > openPrice && trailingLevel > openPrice) // Eseguito una sola volta per posizione. Imposta il primo SL.                   trade.PositionModify(ticket,trailingLevel,takeProfit); // Modifica il Trailing Stop usando "CTrade.trade"               }             if(bidPrice > openPrice && trailingLevel > stopLoss) // controlla se il livello di trailing è sopra il livello precedente.               {                trade.PositionModify(ticket,trailingLevel,takeProfit); // Modifica il Trailing Stop usando "CTrade.trade"               }            }          if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)            {             double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);             double stopLoss  = PositionGetDouble(POSITION_SL);             double takeProfit = PositionGetDouble(POSITION_TP);             double bidPrice  = SymbolInfoDouble(_Symbol,SYMBOL_BID);             double askPrice  = SymbolInfoDouble(_Symbol,SYMBOL_ASK);             ulong ticket = PositionGetTicket(count);             double trailingLevel = NormalizeDouble(askPrice + (Trailing_Step * Point()),_Digits);             if(stopLoss < openPrice) // Se non esiste Stop Loss               {                if(askPrice < openPrice && trailingLevel < openPrice) // Eseguito una sola volta per posizione. Imposta il primo SL.                   trade.PositionModify(ticket,trailingLevel,takeProfit); // Modifica il Trailing Stop usando "CTrade.trade"               }             if(askPrice < openPrice && trailingLevel < stopLoss) // controlla se il livello di trailing è sopra il livello precedente.               {                trade.PositionModify(ticket,trailingLevel,takeProfit); // Modifica il Trailing Stop usando "CTrade.trade"               }            }         }      }

2024.04.05
Codice Semplice per Rilevare una Nuova Candela in MetaTrader 5
MetaTrader5
Codice Semplice per Rilevare una Nuova Candela in MetaTrader 5

In questo articolo, esploreremo un codice semplice che ti permette di rilevare una nuova candela in MetaTrader 5. È una funzionalità utile per chiunque voglia automatizzare il proprio trading e tenere traccia dei cambiamenti dei prezzi in tempo reale. Il principio di base del codice è piuttosto semplice. Prima di tutto, il codice memorizza il tempo dell'ultima candela. Successivamente, aggiunge 60 secondi (che corrispondono a 1 minuto, ma puoi modificare il tempo secondo le tue esigenze) al tempo dell'ultima candela per ottenere il valore di chiusura della candela corrente. Quando: Tempo Corrente = valore di chiusura della candela corrente, significa che una nuova candela è stata ricevuta e la candela corrente è chiusa. In questo codice, il flag (la variabile booleana NewBarReceived) evita che il blocco di codice venga chiamato più volte. Questo significa che il blocco di codice viene eseguito solo una volta per ogni candela. Le funzioni Comment(); e PlaySound("ok.wav"); sono utilizzate per controllare l'accuratezza del blocco di codice. Puoi rimuoverle se non ne hai bisogno. Il flag viene reimpostato su false una volta che il Tempo Corrente supera il valore di chiusura della candela corrente, permettendo di controllare l'arrivo della candela successiva. (Controlla i commenti per maggiori dettagli). //+------------------------------------------------------------------+ //|                      Rilevazione Nuova Candela.mq5 | //|                      di H A T Lakmal | //|                       https://t.me/Lakmal846 | //+------------------------------------------------------------------+ bool NewBarReceived = false; // Flag di controllo. //+------------------------------------------------------------------+ //| Funzione di inizializzazione dell'Expert         | //+------------------------------------------------------------------+ int OnInit()   { //--- crea timer    EventSetTimer(60); //---    return(INIT_SUCCEEDED);   } //+------------------------------------------------------------------+ //| Funzione di deinizializzazione dell'Expert       | //+------------------------------------------------------------------+ void OnDeinit(const int reason)   { //--- distruggi il timer    EventKillTimer();   } //+------------------------------------------------------------------+ //| Funzione tick dell'Expert           | //+------------------------------------------------------------------+ void OnTick()   {    datetime TimePreviousBar = iTime(_Symbol,PERIOD_M1,1);    datetime TimeCurrentClose = TimePreviousBar + 60; // Tempo di chiusura della candela corrente.    datetime Time_Current = TimeCurrent();    if(Time_Current == TimeCurrentClose && NewBarReceived == false)      {       PlaySound("ok.wav");   // Per verificare che funzioni correttamente.       NewBarReceived = true; // Aggiorna il flag per evitare chiamate multiple.       // Inserisci il tuo codice qui ----- (Fai qualcosa)      }    else       if(Time_Current > TimeCurrentClose)         {          NewBarReceived = false; // Reimposta il flag per l'apertura della prossima candela.          // Inserisci il tuo codice qui ----- (Fai qualcosa)         }    Comment("\n" +  "\n" +  "Tempo Candela Corrente -: " + TimeToString(TimePreviousBar,TIME_DATE|TIME_MINUTES|TIME_SECONDS) +            "\n" + "Tempo Chiusura Corrente -: " +TimeToString(TimeCurrentClose,TIME_DATE|TIME_MINUTES|TIME_SECONDS) +            "\n" + "Tempo Corrente -: " + TimeToString(Time_Current,TIME_DATE|TIME_MINUTES|TIME_SECONDS) + "\n" +"\n" + "Nuova Candela Ricevuta -: " + NewBarReceived); // Per controllare i calcoli   } //+------------------------------------------------------------------+ //| Funzione timer               | //+------------------------------------------------------------------+ void OnTimer()   { //---   } //+------------------------------------------------------------------+ //| Funzione di trading           | //+------------------------------------------------------------------+ void OnTrade()   { //---   } //+------------------------------------------------------------------+ //| Funzione ChartEvent           | //+------------------------------------------------------------------+ void OnChartEvent(const int id,                   const long &lparam,                   const double &dparam,                   const string &sparam)   { //---   } //+------------------------------------------------------------------+  

2024.04.05
Chiudi_in_Profitto_o_Perdita_con_MetaTrader 4: Ottimizzazione dell'Expert Advisor
MetaTrader4
Chiudi_in_Profitto_o_Perdita_con_MetaTrader 4: Ottimizzazione dell'Expert Advisor

//+------------------------------------------------------------------------------------------------------------------------------+ //| Chiudi_in_Profitto_o_Perdita: Ottimizzazione V2: Ecco le novità: //| //| 1. Gestione degli Errori: Il codice ora include una gestione degli errori per affrontare situazioni in cui non è possibile chiudere o eliminare ordini. //| 2. Ottimizzazione del Codice: Abbiamo ottimizzato il codice per evitare ripetizioni e migliorare la leggibilità. //| 3. Efficienza: Rimosse le loop o i calcoli non necessari. //| 4. Pulizia di tutti gli oggetti del grafico al momento della deinizializzazione dell'EA. //+------------------------------------------------------------------------------------------------------------------------------+ Impostando a 0, l'EA non farà nulla.    La chiusura positiva in valuta di conto deve essere superiore all'importo attuale di Equity, altrimenti le operazioni verranno eseguite immediatamente. Esempio: Se l'Equity è 55.000€ e la chiusura positiva in valuta di conto è impostata a 55.500€ per guadagnare 500€. Chiusura_Positiva_in_Valuta_Di_Conto  > 0 && <  55.000€ = esecuzione immediata La chiusura negativa in valuta di conto deve essere inferiore all'importo attuale di Equity, altrimenti le operazioni verranno eseguite immediatamente. Esempio: Se l'Equity è 55.000€ e la chiusura negativa in valuta di conto è impostata a 54.500€ per perdere solo 500€. Chiusura_Negativa_in_Valuta_Di_Conto  > 55.000€ = esecuzione immediata È possibile evitare i picchi di spread riducendo il valore dello spread, ma il mercato farà sempre ciò che vuole e potrebbero verificarsi guadagni o perdite maggiori.  Inoltre, se lo spread è impostato al di sotto dello spread medio per le coppie trattate, quelle posizioni non verranno eseguite.  ATTENZIONE: Utilizza questo software a tuo rischio e pericolo. Il mercato Forex è molto volatile!  #property copyright     "Copyright 2024, MetaQuotes Ltd." #property link          "https://www.mql5.com" #property version       "1.01" #property description   "persinaru@gmail.com" #property description   "IP 2024 - open source gratuito" #property description   "Questo EA chiude tutte le operazioni in Profitto e Perdite calcolate in valuta di conto." #property description   "" #property description   "ATTENZIONE: Utilizza questo software a tuo rischio e pericolo." #property description   "Il creatore di questo script non può essere ritenuto responsabile per eventuali danni o perdite." #property description   "" #property strict #property show_inputs extern string  Chiudere = "EA chiude tutte le operazioni e gli ordini in sospeso quando viene raggiunto un profitto o una perdita. I profitti e le perdite sono calcolati in valuta di conto.";  extern int Chiusura_Positiva_in_Valuta_Di_Conto     = 0;  extern int Chiusura_Negativa_in_Valuta_Di_Conto     = 0;  extern int Spread = 10;

2024.03.25
Scopri l'uso delle Reti Neurali nel Trading Algoritmico con MQL5
MetaTrader5
Scopri l'uso delle Reti Neurali nel Trading Algoritmico con MQL5

Introduzione alle Reti Neurali nel Trading Se sei un trader algoritmico e vuoi scoprire come utilizzare l'intelligenza artificiale nel tuo trading, il libro "Reti Neurali per il Trading Algoritmico con MQL5" è il tuo alleato ideale. Qui troverai una guida pratica per imparare a creare strategie di trading utilizzando tecniche avanzate di machine learning. Contenuti del Libro Il libro è composto da 7 capitoli ricchi di informazioni utili per iniziare a lavorare con le reti neurali e integrarle nei tuoi robot di trading in MQL5. Grazie a spiegazioni chiare e semplici, potrai apprendere i fondamenti del machine learning e scoprire i diversi tipi di reti neurali, come i modelli convoluzionali e ricorrenti, fino a soluzioni architetturali più complesse e meccanismi di attenzione. Esempi Pratici e Integrazione Una delle parti più interessanti di questo libro è la vasta gamma di esempi pratici che ti guideranno nell'integrazione di queste soluzioni nei tuoi robot di trading. Inoltre, vengono esplorati vari metodi per migliorare la convergenza dei modelli, come la Normalizzazione Batch e il Dropout. Formazione e Applicazione delle Reti Neurali Il nostro autore offre anche indicazioni pratiche su come addestrare le reti neurali e integrarle nelle tue strategie di trading. Imparerai come creare Expert Advisors per testare le performance dei modelli addestrati su nuovi dati, permettendoti di valutare il loro potenziale nei mercati finanziari reali. Conclusione "Reti Neurali per il Trading Algoritmico con MQL5" non è solo un libro, ma una guida pratica per aiutarti a integrare tecniche decisionali avanzate nei tuoi algoritmi di trading, con la possibilità di migliorare i risultati finanziari. Inizia oggi a scoprire le potenzialità del machine learning e porta il tuo trading a un livello superiore!

2024.02.29
EA Manuale Buy Sell Close: Un Alleato per i Nuovi Trader su MetaTrader 4
MetaTrader4
EA Manuale Buy Sell Close: Un Alleato per i Nuovi Trader su MetaTrader 4

Se sei un trader alle prime armi, l'EA manuale Buy Sell Close è uno strumento che può davvero fare la differenza. Questo Expert Advisor è progettato per facilitare il tuo approccio al trading, permettendoti di testare le tue strategie sia in modalità visuale che in tempo reale. Con Buy Sell Close, puoi esercitarti con il tuo sistema di trading attraverso il backtesting. È un modo fantastico per affinare le tue abilità senza rischiare il tuo capitale. Questo EA ti permette di gestire manualmente il trading, con opzioni per mettere in pausa o modificare la velocità della revisione del backtest, rendendo le esercitazioni di trading manuali molto più semplici e intuitive. Introduzione: 1. Il pulsante [Lots] ti consente di modificare il numero di lotti dopo l'inserimento nel campo. 2. Il pulsante [BUY] permette di aprire un ordine di acquisto aggiuntivo basato sul numero di lotti selezionato. 3. Il pulsante [SELL] apre un ordine di vendita per la dimensione di lotto specificata. 4. Il pulsante [SL Modify TP] modifica lo Stop Loss e il Take Profit per tutti gli ordini in base al prezzo attuale. 5. Il pulsante [Close All Buy] chiude tutti gli ordini di acquisto aperti. 6. Il pulsante [Close All Sell] chiude tutti gli ordini di vendita aperti. 7. Il pulsante [Close All Orders] chiude tutti gli ordini aperti. 8. Il lato destro della schermata mostra gli ordini aperti, i profitti e altre informazioni utili. Descrizione dei parametri: 1. MM: calcola automaticamente la dimensione dei lotti in base al rapporto di rischio. 2. Risk: 0.2 per un saldo di 10.000 corrisponde a 0.2 lotti. 3. Lots: lotti fissi se MM è impostato su FALSE, utilizzerà questo numero fisso di lotti. 4. SL: Stop Loss: di default è 250 micro-punti. 5. TP: Take Profit: di default è 500 micro-punti. Puoi esercitarti con il tuo sistema di trading grazie a questa risorsa. Buon trading a tutti!

2024.02.29
Primo Precedente 2 3 4 5 6 7 8 9 10 11 12 Successivo Ultimo