Programmare un robot Forex: crea il tuo robot di trading

Quali tipi di codice si possono programmare in MQL4 e MQL5?

Gli esempi presentati qui si basano sui linguaggi di programmazione MQL4 e MQL5. In questo ambiente è possibile scrivere tre tipi di codice:

• Expert Advisor (robot per il Forex)
• Indicatori personalizzati
• Script

1. L'Expert Advisor (EA)

Rappresenta l'automazione di un sistema di trading manuale applicato al grafico di uno strumento finanziario selezionato. In altre parole, qualsiasi codice scritto per un EA deve essere sviluppato tenendo sempre presente il grafico del rispettivo asset.

Alcuni eventi vengono eseguiti una sola volta, mentre altri continuano a ripetersi fino a quando non ricevono un comando di arresto. Di conseguenza, un EA inizia a operare nel momento in cui si attivano gli eventi che compongono la sequenza di inizializzazione (init) del codice. 

Tra questi eventi rientrano l'arrivo di un nuovo tick di prezzo, un evento sul grafico o un evento personalizzato. Una volta attivati, l'EA invia un ordine al server del broker per aprire o chiudere un'operazione. I file degli EA vengono salvati nella cartella MQL4/Experts del client MT4. 

2. Lo script

È un blocco di codice progettato per eseguire determinate funzioni una sola volta, come l'evento Start. I file degli script vengono salvati nella cartella MQL4/scripts del client MT4. 

3. L'indicatore personalizzato

Si tratta di un indicatore tecnico su misura, non presente tra quelli predefiniti su MT4. Gli indicatori non aprono trade direttamente, ma servono a identificare condizioni sul grafico che possono dare il via a operazioni manuali o automatizzate tramite EA. I relativi file vengono salvati nella cartella MQL4/indicators del client MT4. 

Come creare un robot per il Forex con il codice MQL4/MQL5 

Il codice scritto per un robot di trading per il Forex, un indicatore o uno script in ambiente MQL4/MQL5 comprende sintassi, variabili, espressioni e istruzioni condizionali. Ecco come costruire il tuo robot combinando questi quattro elementi: 

Nel resto dell'articolo faremo riferimento principalmente a MQL4, ma gli stessi concetti si applicano anche a MQL5.

1. Prendi familiarità con la sintassi

La sintassi di programmazione è l'insieme di regole e convenzioni che disciplinano la scrittura e la struttura del codice all'interno di uno specifico linguaggio.

La corretta compilazione ed esecuzione del codice di un robot per il Forex dipendono dalla stesura di una sintassi priva di errori e conforme al linguaggio scelto per sviluppare l'Expert Advisor, lo script o l'indicatore. 

Ecco alcuni elementi fondamentali della sintassi MQL4:

• Commenti: righe di testo all'interno di un programma che vengono ignorate dal compilatore o dall'interprete. Vengono usate per spiegare il funzionamento del codice, rendendolo comprensibile a sé stessi e ad altri. Devono essere racchiusi tra /* e */ per i commenti su più righe, oppure preceduti da // per i commenti su riga singola.
• Variabili: aree con nome nella memoria del computer utilizzate per memorizzare dati. Il valore contenuto in una variabile può variare durante l'esecuzione del programma.
• Tipi di dato: classificazioni che specificano quale tipologia di valore può contenere una variabile. Alcuni esempi sono int (numeri interi), double (numeri a virgola mobile per i prezzi), bool (vero/falso), string (testo), datetime (data e ora) e color.
• Identificatori: nomi assegnati agli elementi del programma, come variabili, funzioni, classi o moduli. Devono iniziare con una lettera o un trattino basso, possono contenere lettere, cifre e trattini bassi, e hanno una lunghezza massima di 63 caratteri. Inoltre, non possono coincidere con le parole riservate di MQL4.
• Operatori: simboli che agiscono su uno o più operandi (valori o variabili). Vengono impiegati per operazioni aritmetiche, di confronto, logiche o di assegnazione. Alcuni esempi includono +, -, =, !=, || e &&.
• Istruzioni condizionali: controllano il flusso eseguendo blocchi di codice differenti a seconda che una condizione risulti vera o falsa. Ne sono un esempio le istruzioni "if", "else if" ed "else".
• Cicli: controllano il flusso di esecuzione, consentendo di ripetere un blocco di codice finché una condizione rimane soddisfatta. Si usano per scorrere insiemi di dati o svolgere compiti ripetitivi. Tra i costrutti di ciclo figurano "for", "while" e "do-while".
• Funzioni: blocchi di codice dedicati a un'operazione specifica. Suddividono i programmi in parti più piccole, rendendoli più leggibili e meno ridondanti.

L'ambiente di programmazione MQL4 è progettato per supportare un'ampia varietà di costrutti sintattici, offrendo al programmatore gli strumenti adatti per sviluppare indicatori e bot di trading per il Forex solidi ed efficienti.

2. Inizia con dichiarazione e inizializzazione

Le variabili sono i mattoni fondamentali del codice. Prima di poter utilizzare una variabile, però, devi crearla: questa operazione si chiama dichiarazione. I termini "creare" o "dichiarare" vengono spesso usati come sinonimi, ma nel gergo informatico la dicitura corretta è dichiarazione. Dichiarare una variabile indica al codice di crearla assegnandole un tipo di dato. 

Per dichiarare una variabile: 

• scrivi il tipo di dato, seguito da uno spazio 
• scrivi il nome della variabile 
• chiudi la riga con un punto e virgola (;). 

Ecco come viene dichiarata una variabile con tipo di dato intero (int):

• In questo caso il tipo di dato è int per i numeri interi.
• Il nome della variabile è hi
• La riga termina con un punto e virgola.

Le variabili vengono definite specificando un tipo di dato (come int per gli interi o double per i numeri a virgola mobile), seguito dal nome assegnato alla variabile (identificatore). Per creare una variabile devi prima stabilirne il tipo di dato. I più utilizzati sono:

1. Intero (int): rappresenta qualsiasi numero compreso tra -2 miliardi e +2 miliardi. I tipi int non possono memorizzare cifre decimali.
2. Double: rappresenta numeri compresi tra -1,79 X 10³⁰⁸ e +1,79 X 10³⁰⁸. Con il tipo double puoi salvare dati che includono valori decimali.
3. Booleano (bool): rappresenta un valore logico che definisce vero (true) o falso (false).
4. Color: memorizza un valore cromatico.
5. String: una stringa è una sequenza di testo.
6. DateTime: memorizza data e ora. 

Supponiamo, per esempio, di avere le variabili x, y e z con i valori interi 10, 7 e 5. Puoi decidere di definire una nuova informazione per la variabile a impostando a = y + z. Conoscendo già i valori di y e z, ne consegue che a = 12.

Ad esempio, per dichiarare una variabile intera chiamata "myVar", utilizzerai la seguente sintassi:

int myVar

Puoi anche assegnare un valore a una variabile al momento della dichiarazione. Supponiamo di voler assegnare il valore 12. Useremo la seguente sintassi per dichiarare questo valore alla variabile intera myVar. 

int myVar = 10;

Una volta dichiarata, la variabile può essere utilizzata nel codice MQL per svolgere varie funzioni o semplicemente per archiviare dati. Se vuoi scrivere il codice che definisce la nuova variabile a come somma degli interi y + z, puoi impostarlo in questo modo: 

int var1 = 10;
int var2 = 7;
Int var3 = 5

int result = var2 + var3; // result = 12

In questo esempio hai dichiarato tre variabili intere, denominate var1, var2 e var3 (o x, y e z), assegnando loro rispettivamente i valori 10, 7 e 5. Ti interessa sommare solo var2 e var3 per ottenere un nuovo intero per la nuova variabile a. Utilizzi il segno + come operatore, e int result rappresenta la nuova variabile per a. Il valore di result sarà 12, ossia la somma di var2 e var3.

Nell'operatività di trading, una funzione pratica fondamentale delle variabili è memorizzare valori che cambiano nel tempo, come il prezzo di uno strumento. Le quotazioni valutarie oscillano costantemente: una variabile ti permette di registrare e aggiornare questo dato a ogni nuova variazione di tick. 

double price;

price = SymbolInfoDouble(_Symbol, SYMBOL_BID); // get the current bid price

ol, SYMBOL_BID); // get the current bid price

In un mercato dinamico come quello del Forex, integrare le variabili nella strategia del tuo robot di trading per il Forex è essenziale per seguire le oscillazioni dei prezzi e adeguarsi ai continui cambiamenti del mercato.

3. Espressioni

Le operazioni sono simili ai normali calcoli aritmetici come addizioni, sottrazioni, moltiplicazioni e divisioni. Vengono indicate con simboli operativi o operatori. Quando questi simboli vengono combinati con le variabili all'interno della stessa riga di codice, formano delle espressioni. 

Ecco i principali operatori utilizzati nel codice MQL4:

a) Operatori aritmetici: più, meno, percentuale/modulo, divisione, moltiplicazione (+ - % / *)

b) Operatori logici: && ||

c) Operatori di assegnazione: uguale, più uguale, moltiplicazione uguale (= += *=)

Un'espressione che si conclude con un punto e virgola (;) costituisce un'istruzione. Ma quali sono le espressioni più rilevanti per chi programma in MQL4?

Gli operatori aritmetici servono per eseguire calcoli matematici su valori numerici. Ecco come si presentano: 

L'operatore ++ indica al programma di aumentare di 1 il valore di b alla riga 27: se b = 70, il codice assegnerà un valore di 70 + 1 (ossia 71) ogni volta che incontra b++. Allo stesso modo, l'operatore -- indica di ridurre di 1 il valore di b alla riga 28, assegnando il valore 69 quando viene eseguito bb--.

Ecco un altro esempio di espressione con operatore aritmetico:

La direttiva '#include <math.mqh>' istruisce il compilatore ad abilitare le funzioni della libreria Math, evitando errori durante la compilazione del codice. Le funzioni matematiche mostrate qui sono MathPow() e MathSqrt().

Vediamo nel dettaglio il significato di ciascun operatore aritmetico: 

• Addizione (+): somma i valori numerici posti a sinistra e a destra dell'operatore.
• Sottrazione (-): sottrae il valore numerico a destra dell'operatore da quello a sinistra.
• Moltiplicazione (*): moltiplica i valori posti a sinistra e a destra dell'operatore.
• Divisione (/): divide il valore numerico a sinistra dell'operatore per quello a destra. 
• Modulo (%): restituisce il resto della divisione tra il valore a sinistra e quello a destra dell'operatore.

Ecco come appaiono nell'ambiente di programmazione MQL4:

Il numero 10 è divisibile esattamente per 5 due volte senza resto: per questo motivo 10 % 5 restituirà 0 alla riga 23.

Gli operatori di assegnazione vengono utilizzati per attribuire un valore a una variabile. Ecco il significato dei vari operatori (= += -= *=):

• Assegnazione (=): assegna il valore presente a destra dell'operatore alla variabile a sinistra.
• Assegnazione con addizione (+=): aggiunge il valore a destra a quello già contenuto nella variabile a sinistra, assegnando il risultato a quest'ultima per darle un nuovo valore.
• Assegnazione con sottrazione (-=): sottrae il valore a destra da quello della variabile a sinistra, assegnando il risultato alla variabile a sinistra per aggiornarne il valore.
• Assegnazione con moltiplicazione (*=): moltiplica il valore a destra per quello della variabile a sinistra, assegnando il risultato alla variabile a sinistra.
• Assegnazione con divisione (/=): divide il valore della variabile a sinistra per il valore a destra dell'operatore, assegnando il risultato alla variabile a sinistra.
• Assegnazione con modulo (%=): calcola il resto della divisione tra il valore della variabile a sinistra e quello a destra, assegnando il risultato alla variabile a sinistra.

Ecco alcuni esempi pratici di utilizzo degli operatori di assegnazione in MQL4:

4. Operatori condizionali (if/else, switch)

Gli operatori condizionali permettono di eseguire determinate istruzioni solo quando i parametri di un'altra funzione risultano soddisfatti. In sostanza, consentono di compiere un'azione solo se una determinata condizione è vera. 

Su MT4, le istruzioni condizionali principali sono "if-else" e "switch". Entrambe servono a gestire l'esecuzione del codice sulla base di condizioni specifiche. 

Istruzione if-else

Il costrutto "if-else" viene solitamente impiegato quando è necessario verificare una serie di condizioni all'interno del codice:

Se questo script viene compilato ed eseguito, stamperà 10 perché la condizione è vera. Se devi eseguire più righe di codice sotto questa condizione, basta racchiuderle tra parentesi graffe.

Nel contesto operativo dei mercati, il costrutto if-else serve a stabilire in che modo il codice deve elaborare le variabili relative ai prezzi.

Ecco un esempio pratico di come funziona la condizione if-else. In questo caso, alla variabile "price" viene assegnato come valore predefinito il prezzo Ask di mercato. La parte "if" verifica se il prezzo è superiore a 1,0: se sì, viene eseguito esclusivamente il codice all'interno delle prime parentesi graffe. In caso contrario (ovvero prezzo < o = 1,0), verrà eseguito soltanto il blocco contenuto nelle seconde parentesi graffe. 

//+--------------------------------------------------------+
//| Script program start function                          |
//+--------------------------------------------------------+
void OnStart(){
    double price = Bid;
    if (price > 1.0) {
        // Execute this code if price is greater than 1.0
        Alert("Price is above 1.0");
    }else if (price < 0.5) {
        // Execute this code if price is less than 0.5
        Alert("Price is below 0.5");
    }else {
        // Execute this code if price is between 0.5 and 1.0
        Alert("Price is between 0.5 and 1.0");
    }
}

Puoi anche inserire un'altra istruzione "if-else" all'interno di una già esistente, cioè dentro le parentesi graffe dei blocchi "if" o "else". Questa struttura prende il nome di if-else annidato. Ecco un esempio illustrativo:

L'istruzione if-else annidata indica al codice di verificare se il prezzo è < 0,8 oppure compreso tra 0,8 e il target prefissato. Se il prezzo è inferiore a 0,8, viene eseguito il codice interno al blocco if annidato; in caso contrario, verrà eseguito il rispettivo blocco else. 

Gli operatori condizionali trovano impiego nelle operazioni di trading per gestire ordini pendenti di ingresso e ordini di uscita, come ordini Buy Limit/Sell Limit, Buy Stop/Sell Stop e Take Profit/Stop Loss. Come puoi notare, si tratta di ordini che scattano soltanto al verificarsi di determinate condizioni di prezzo: se tali parametri non vengono raggiunti, l'ordine non viene eseguito. Ecco come verrebbe scritto in MQL4 il codice per queste condizioni di ingresso a mercato.

Buy Stop

Per inserire un ordine Buy Stop a un determinato livello di prezzo, puoi utilizzare il codice seguente. Il codice indica al robot di trading per il Forex di eseguire queste operazioni:

– inserire un ordine BUY STOP a una distanza di stop di 10 pip dal prezzo corrente, con una distanza limite di 20 pip.

– utilizzare 1 lotto standard (1,0 lotti) come dimensione dell'operazione. 

– applicare una linea verde sul grafico in corrispondenza del prezzo di ingresso dell'ordine per facilitarne l'individuazione visiva.

– assegnare un numero identificativo univoco a questo trade. 

//+------------------------------------------------------------------+
//| Expert tick function                                           |
//+------------------------------------------------------------------+
void OnTick()
{
    //---
    double StopDistance = 10.0;     // Stop distance in pips
    double LimitDistance = 20.0;    // Limit distance in pips
    double Lots = 1.0;              // Lot size
    int Slippage = 3;               // Maximum price deviation
    int MagicNumber = 12345;        // Unique identifier
    color Green = Lime;             // Order line color

    // Get the current ask price
    double price = Ask;

    // Calculate the stop and limit prices
    double stopPrice = NormalizeDouble(price + StopDistance * Point, Digits);
    double limitPrice = NormalizeDouble(price + LimitDistance * Point, Digits);

    // Place the buy stop order
    int ticket = OrderSend(Symbol(), OP_BUYSTOP, Lots, stopPrice, Slippage, limitPrice, 0, "", MagicNumber, 0, Green);

    if(ticket > 0)
    {
        Print("Buy stop order placed successfully with ticket #", ticket);
    }
    else
    {
        Print("Error placing buy stop order. Error code:", GetLastError());
    }
}

Il codice definisce le seguenti variabili: 

• StopDistance
• LimitDistance
• Lots
• Slippage
• MagicNumber
• Green 

Una volta inoltrato l'ordine, il codice controlla l'esito dell'operazione tramite il valore restituito dalla funzione OrderSend() (il ticket). Se l'ordine Buy Stop viene eseguito con successo, il codice visualizzerà un messaggio nella scheda Diario di MT4. In caso contrario, stamperà un messaggio di errore con il relativo codice numerico.

Sell Limit

Per inserire un ordine Sell Limit a un determinato livello di prezzo, puoi utilizzare questo codice:

// Define order parameters

double lotSize = 0.1;  // Lot size
double limitPrice = 1.2000;  // Limit price
double stopLoss = 1.2100;  // Stop loss
double takeProfit = 1.1900;  // Take profit
int slippage = 3;  // Maximum deviation in pips from the requested price

// Place sell limit order
bool sellLimitOrderPlaced = false;
int ticket = 0;

while (!sellLimitOrderPlaced) {    
      ticket = OrderSend(Symbol(), OP_SELLLIMIT, lotSize, limitPrice, slippage, stopLoss, takeProfit, "Sell Limit", MagicNumber, 0, Red);    
      if (ticket > 0) {        
         sellLimitOrderPlaced = true;    
      } else {
         Print("Sell limit order failed with error code ", GetLastError());
         Sleep(5000);  // Wait for 5 seconds before retrying
      }
}

// Check if the order is still open
while (OrderSelect(ticket, SELECT_BY_TICKET)){    
      if (OrderCloseTime() > 0) {
         // Order has been closed        
         break;   
      }    

      // Wait for 1 second before checking again    
      Sleep(1000);
}

Stop Loss

Ecco come istruire il robot di trading per il Forex a impostare uno stop loss su un trade. La gestione dello stop loss richiede attenzione: alcuni programmatori preferiscono configurarlo solo nel momento in cui l'ordine risulta effettivamente attivo. In questo caso, il codice interviene per modificare lo stop loss in un secondo momento.

In questo frammento di codice, all'EA viene indicato di inviare un ordine pendente e successivamente di aggiornarne lo stop loss non appena l'ordine viene eseguito. 

// Define order parameters
double lotSize = 0.1;  // Lot size
double limitPrice = 1.2000;  // Limit price
double stopLoss = 1.2100;  // Stop loss
double takeProfit = 1.1900;  // Take profit

// Place the pending order
int ticket = OrderSend(Symbol(), OP_SELLLIMIT, lotSize, limitPrice, 0, stopLoss, takeProfit, "Sell Limit", MagicNumber, 0, Red);
if (ticket <= 0) {
    Print("Failed to place pending order with error code ", GetLastError());
} else {
    Print("Pending order placed with ticket number ", ticket);
}

// Modify the stop loss for the pending order
if (OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES)) {
    double newStopLoss = 1.2050;  // New stop loss value    
    if (!OrderModify(ticket, OrderOpenPrice(), newStopLoss, OrderTakeProfit(), 0, Green)) {
        Print("Failed to set stop loss for pending order with error code ", GetLastError());
    } else {
        Print("Stop loss set for pending order with ticket number ", ticket);
    }
} else {
    Print("Failed to select pending order with ticket number ", ticket, " with error code ", GetLastError());
}

Le variabili all'interno del codice sono ben definite:

• la dimensione dell'ordine è pari a 1 mini lotto (0,1 lotti)
• il prezzo limite è 1.2000
• lo stop loss è 1.2100
• il take profit è 1.1900

Il codice include anche l'istruzione di stampare sul diario i codici di errore nel caso in cui non sia possibile modificare lo stop loss. L'ordine pendente viene inviato tramite la funzione OrderSend, utilizzando le variabili descritte come parametri.

Se l'ordine va a buon fine, il codice indica al robot di trading per il Forex di utilizzare la funzione OrderSelect (che fa riferimento al numero di ticket per l'identificazione). Il flag MODE_TRADES indica al robot di selezionare ordini aperti e pendenti per questa operazione. 

Puoi inoltre usare la funzione OrderModify per aggiornare i parametri dell'ordine e la funzione newStopLoss per impostare il nuovo livello di stop loss. 

Ricorda che, quando imposti queste variabili, è fondamentale verificare con il tuo broker le regole relative al numero di modifiche consentite per ciascun ordine. 

Take Profit

Se non desideri impostare il Take Profit insieme allo stop loss come mostrato sopra, puoi definirlo separatamente tramite un altro blocco di codice. Puoi usare la seguente struttura:

void OnTick()  {

// Set take profit level
double takeProfit = 1.5; // Take profit level as a multiple of the trade's open price
double stopLoss = 1.0; // Stop loss level as a multiple of the trade's open price

// Place trade with take profit and stop loss levels
int ticket = OrderSend(Symbol(), OP_BUY, 1.0, Ask, 3, Bid - stopLoss * Point, Bid + takeProfit * Point, "My Order", MagicNumber, 0, Blue);
}

In questo esempio è stato scelto un rapporto rischio/rendimento di 1:1,5 sia per lo stop loss sia per il take profit. Il TP corrisponde quindi a 1,5 volte il valore impostato rispetto al prezzo di ingresso. Anche in questo caso, l'operazione viene inserita tramite la funzione OrderSend dopo aver definito le variabili stopLoss e takeProfit.

Switch

L'istruzione "switch" viene invece impiegata quando occorre confrontare una variabile con una serie di possibili valori alternativi. Ecco un esempio pratico su come utilizzare "if-else" e "switch" in MT4:

double price = Bid;
int tradeType = 2; // 0 = buy, 1 = sell, 2 = do nothing

// if-else statement
if (price > 1.0) {
    tradeType = 0;
}else if (price < 0.5) {
    tradeType = 1;
}

// switch statement
switch (tradeType) {
    case 0:
        // Execute this code if tradeType is 0 (buy)
        OrderSend(Symbol(), OP_BUY, 0.1, price, 0, 0, 0, "Buy order", 0, 0, Green);
        break;
    case 1:
        // Execute this code if tradeType is 1 (sell)
        OrderSend(Symbol(), OP_SELL, 0.1, price, 0, 0, 0, "Sell order", 0, 0, Red);
        break;
    default:
        // Execute this code if tradeType is not 0 or 1 (do nothing)
        break;
}

Il costrutto if/else indica al codice di effettuare verifiche ed esecuzioni a partire dal livello di prezzo.

• Se il prezzo è > 1,0, la variabile tradeType = 0 -> BUY.
• Se la variabile di prezzo è < 0,5, la variabile tradeType = 1 -> SELL. 
• Se il prezzo è al livello Bid attuale (impostazione predefinita), tradeType = 2 -> NESSUNA AZIONE. 

Con l'istruzione switch la logica è diversa: il codice concentra la verifica direttamente sul valore della variabile tradeType. 

• Se tradeType = 0 -> BUY al livello di prezzo impostato nel codice.
• Se tradeType = 1 -> SELL al prezzo definito. 
• Se tradeType = 2 -> NESSUNA AZIONE.

Segui queste guide per scoprire come installare il tuo robot per il Forex sui tuoi terminali di trading:
Come installare un bot di trading per il Forex su MT4
Come installare un bot di trading per il Forex su MT5

Conclusione

In questo articolo abbiamo esaminato i concetti e le componenti fondamentali che costituiscono il codice di un robot per il Forex e lo sviluppo di sistemi di trading automatico. Abbiamo visto le tipologie di codice realizzabili in MQL4 (bot di trading per il Forex, indicatori e script) e i diversi formati logici che ne definiscono il funzionamento. Ora disponi delle basi necessarie su commenti, identificatori e altri elementi chiave della sintassi. 

Padroneggiare a fondo questi argomenti richiede tempo e tanta pratica sul campo. Ci auguriamo che queste nozioni ti abbiano aiutato a comprendere cosa c'è dietro la programmazione di un robot per il Forex.