Trading Sistematico

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
Come Calcolare il Bounce Number per Strategie Grid e Martingale su MetaTrader 4
MetaTrader4
Come Calcolare il Bounce Number per Strategie Grid e Martingale su MetaTrader 4

La dimensione dei lotti e il numero di operazioni per strategie come Grid e Martingale sono fondamentali per il successo nel trading. Ci poniamo sempre domande su cosa sia successo nella storia di un simbolo durante le zone di range, e Quante volte il prezzo ha rimbalzato tra due livelli di una zona di range?! Questo è ciò che definisco come Bounce Number. Può essere calcolato attraverso un'analisi statistica della storia di qualsiasi simbolo sul mercato. Per chiarire meglio, diamo un'occhiata all'immagine n. 1. Immagine n. 1: Definizione di Bounce Number, obiettivi e applicazioni L'immagine illustra come il movimento del prezzo genera statistiche per lo strumento del Bounce Number. Per evitare ritardi, ho generato questo strumento come un Expert Advisor utilizzando la funzione Sleep. Questa funzione in qualche modo impedisce il crash del grafico a causa dell'alto numero di candele impostate negli input dello strumento. L'altra immagine (Immagine n. 2) mostra una struttura grafica molto semplice dello strumento e il significato dei suoi oggetti. Immagine n. 2: Statistiche del Bounce Number. Utilizzo dello strumento: Dall'immagine n. 2, considerando di impostare l'Altezza Mezza del Canale di Rimbalzo a 600 punti: ci sono 6 numeri di rimbalzo diversi, da 1 a 6 per questo simbolo. Il numero di rimbalzo 2 significa che il prezzo parte dal centro del canale di rimbalzo (altezza 2 * 600 = 1200 punti) e si muove su e giù colpendo una volta la linea rossa e una volta la linea blu prima di raggiungere il TP=1200 punti. Per il rimbalzo n. 5, il prezzo parte dal punto centrale del canale e colpisce 2 volte la linea rossa e 3 volte la linea blu, oppure 3 volte la linea rossa e 2 volte la linea blu, per poi raggiungere il TP=1200 punti. Lo stesso vale per gli altri numeri di rimbalzo. Non abbiamo il numero di rimbalzo 7, il che significa che non ci sono 7 rimbalzi tra le linee rossa e blu (con una distanza di 1200 punti) nella storia selezionata negli input dello strumento. Tieni presente che se selezioni più dati storici (Numero massimo di candele da analizzare), le possibilità di trovare 7 rimbalzi aumenteranno. Ma come vediamo, anche la possibilità di 6 rimbalzi è 22 su 9020 elementi totali di prezzo che hanno colpito i TP. Cosa c'è negli input dello strumento: Numero massimo di candele da analizzare: Come per altri strumenti di scansione, fai attenzione al numero che imposti in questa cella. Non aumentarlo drasticamente per evitare crash della memoria. Time-Frame: Il Time-Frame delle candele che vogliamo usare per trovare i rimbalzi dai limiti del canale e il contatto con le linee TP. Usa un time-frame più basso per canali sottili. Se non sai cosa impostare, è meglio usare il Time-Frame M1. Altezza Mezza del Canale di Rimbalzo: Questa è la distanza della linea verde dalle linee rossa e blu, espressa in punti. Colore di Sfondo del Grafico Colore del Grafico a Barre 1/Colore del Grafico a Barre 2: per rendere le barre statistiche un po' più accattivanti. Colore delle Celle di Conto Colore delle Celle dei Numeri di Rimbalzo Colore della Barra di Caricamento: Durante il calcolo, questa barra di caricamento aiuterà l'utente a sapere se lo strumento sta funzionando o meno e la velocità dei calcoli. - È stato aggiunto un pulsante per avviare e inserire il numero di candele storiche dallo schermo.

2024.01.12
Allerta Sonora per Connessione e Disconnessione su MetaTrader 5
MetaTrader5
Allerta Sonora per Connessione e Disconnessione su MetaTrader 5

Ciao trader! Oggi voglio parlarvi di un'utilità molto utile per chi utilizza MetaTrader 5: l'allerta sonora per le connessioni e disconnessioni. È un modo semplice per rimanere informati su ciò che accade nel terminale senza doverlo controllare continuamente. Per iniziare, dovete aggiungere i file audio .wav nella cartella MQL5\Files\Sounds. Potete utilizzare suoni personalizzati per le notifiche, rendendo l'esperienza di trading ancora più piacevole. Una volta che avete i suoni pronti, è sufficiente copiare il codice fornito qui sotto e compilarlo come un Utility EA. Nel file allegato troverete delle righe commentate che spiegano come utilizzare la direttiva #resource, la quale potrebbe rendere impossibile il caricamento dei file audio. //+------------------------------------------------------------------+ //|                               Connect_Disconnect_Sound_Alert.mq5 | //|                                Copyright 2024, Rajesh Kumar Nait | //|                  https://www.mql5.com/en/users/rajeshnait/seller | //+------------------------------------------------------------------+ #property copyright "Copyright 2024, Rajesh Kumar Nait" #property link      "https://www.mql5.com/en/users/rajeshnait/seller" #property version   "1.00" #include <Trade/TerminalInfo.mqh> bool     first             = true; bool     Now_IsConnected   = false; bool     Pre_IsConnected   = true; datetime Connect_Start = 0, Connect_Stop = 0; CTerminalInfo terminalInfo; //--- File audio #resource "\Files\Sounds\CONNECTED.wav" #resource "\Files\Sounds\DISCONNECTED.wav" //+------------------------------------------------------------------+ //| Funzione di inizializzazione dell'Expert                                   | //+------------------------------------------------------------------+ int OnInit()   { //---       ResetLastError();       while ( !IsStopped() ) {          Pre_IsConnected = Now_IsConnected;          Now_IsConnected = terminalInfo.IsConnected();          if ( first ) {             Pre_IsConnected = !Now_IsConnected;          }          if ( Now_IsConnected != Pre_IsConnected ) {             if ( Now_IsConnected ) {                Connect_Start = TimeLocal();                if ( !first ) {                   if(!PlaySound("::Files\Sounds\DISCONNECTED.wav"))                      Print("Errore: ",GetLastError());                }                if ( IsStopped() ) {                   break;                }                if(!PlaySound("::Files\Sounds\CONNECTED.wav"))                   Print("Errore: ",GetLastError());             } else {                Connect_Stop = TimeLocal();                if ( !first ) {                   if(!PlaySound("::Files\Sounds\CONNECTED.wav"))                      Print("Errore: ",GetLastError());                }                if ( IsStopped() ) {                   break;                }                if(!PlaySound("::Files\Sounds\DISCONNECTED.wav"))                   Print("Errore: ",GetLastError());             }          }          first = false;          Sleep(1000);       } //---    return(INIT_SUCCEEDED);   } //+------------------------------------------------------------------+

2024.01.08
Strumenti Avanzati di MQL5 per Trader: Sviluppa il Tuo Trading con MetaTrader 5
MetaTrader5
Strumenti Avanzati di MQL5 per Trader: Sviluppa il Tuo Trading con MetaTrader 5

Parte 7. Strumenti Avanzati di MQL5 "Parte 7. Strumenti Avanzati di MQL5" del libro "Programmazione MQL5 per Trader" esplora le capacità avanzate dell'API MQL5, fondamentali per sviluppare programmi per MetaTrader 5. Tra queste troviamo simboli finanziari personalizzati, eventi del calendario economico integrati e tecnologie generali come networking, database e crittografia. Questa sezione si concentra sulle librerie, un tipo speciale di programma che fornisce API già pronte per connettersi ad altri programmi MQL. Viene anche trattata la possibilità di sviluppare pacchetti software e di combinare programmi logicamente interconnessi in progetti. Infine, parleremo delle integrazioni con altri ambienti software, inclusi Python. Iniziamo studiando le risorse, che sono file di qualsiasi tipo che possono essere incorporati nel codice del programma. Le risorse possono contenere: Elementi multimediali Impostazioni "hard" provenienti da programmi esterni Altri programmi MQL5 in forma compilata L'ambiente di sviluppo MQL5 consente di includere array di dati applicativi, immagini, suoni e font nel file sorgente, rendendo il programma un prodotto autonomo e conveniente per l'utente finale. Un'attenzione particolare sarà dedicata alle risorse grafiche con immagini raster in formato BMP: imparerai a creare, modificare e visualizzare queste immagini dinamicamente sul grafico. Concluderemo questa parte finale del libro studiando l'integrazione di OpenCL in MQL5. OpenCL è uno standard aperto per la programmazione parallela in sistemi multiprocessore, inclusi i processori grafici (GPU) e le unità di elaborazione centrale (CPU). Permette l'accelerazione di compiti computazionalmente intensivi, a patto che gli algoritmi possano essere parallelizzati. Questi possono includere l'addestramento di reti neurali, la trasformata di Fourier e la risoluzione di sistemi di equazioni. L'uso di OpenCL nei programmi MQL richiede la presenza di driver speciali del produttore e supporto per OpenCL versione 1.1 e superiori. La presenza di una scheda grafica non è obbligatoria, poiché anche il processore centrale può essere utilizzato per il calcolo parallelo.

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