programmazione
Adesso stai leggendo
Praticamente MQL. Algo Trader cz. I [Corso di programmazione]
0

Praticamente MQL. Algo Trader cz. I [Corso di programmazione]

creato Radek SzafronLuglio 4 2019

Nell'episodio di oggi, inizieremo a lavorare su un software che ti consentirà di sfruttare le opportunità offerte dal trading algoritmico mantenendo il massimo controllo nel corso degli eventi. Ci concentreremo su idee che ti consentono di impegnarti nel trading reale massimizzando l'operatività intuitiva e la flessibilità della funzione. Nel software utilizziamo un'interfaccia, la cui forma è considerata da molti come uno standard nel settore del trading giornaliero e viene spesso chiamata scala dei prezzi.

algotrader

interfaccia

Piano di progetto

Divideremo il lavoro in più fasi, perché oltre alla vasta gestione degli ordini, Algo Trader ti consentirà di eseguire algoritmi che gestiranno automaticamente la posizione in base alle varie combinazioni che puoi creare a seconda della situazione che incontrerai sul mercato.

Nella parte di oggi, faremo il primo passo nel mondo della programmazione orientata agli oggetti e lanceremo una parte elementare del nostro progetto relativa all'interfaccia e al funzionamento delle operazioni di base.

Nei prossimi episodi inizieremo a lavorare sui primi algoritmi. All'inizio creeremo un algoritmo GTP che garantirà che la posizione si chiuda con il profitto atteso indipendentemente dal numero di ordini effettuati. Successivamente, creeremo l'algoritmo OOO (One Opens the Other, così esattamente, non è stato ancora), e infine un algoritmo che abilita lo scalping durante la presentazione di importanti dati macro. Insieme agli algoritmi, qua e là, aggiungeremo dei simpatici gadget.

Background tecnico

Troverete il pacchetto con i file necessari per oggi seguendo questo link:

Utilizzare il software significa accettare la licenza allegata al set di file.

Per il corretto funzionamento del software, è necessaria una versione di Microsoft NET Framework di min. 4.6.1 Runtime, che puoi scaricare qui:

Programmazione orientata agli oggetti

Creeremo il nostro software utilizzando programmazione di oggetti, un metodo di programmazione che consente l'ordinamento logico di frammenti di algoritmo nel cosiddetto oggetti il ​​cui compito è di eseguire funzioni separate e comunicare con altri oggetti al fine di implementare il compito del programma nel suo complesso. Per andare oltre, avremo bisogno di capire quali oggetti sono in pratica e come vengono creati. A tale scopo, dai un'occhiata al seguente articolo in Wikibooks, che - basato sull'esempio del linguaggio C ++ su cui è basato MQL4 - ti permette di capire le basi.

LEGGI L'ARTICOLO

Prima classe

Come puoi vedere, tutto ruota intorno alla parola chiave classe. Ti consente di definire un oggetto che puoi quindi creare con una parola chiave nuovo. Apri il file contenente la definizione di una delle classi che useremo oggi, il file ChartOperations.mqhche troverai nel catalogo MQL4 \ Include \ AlgoTrader_v10.

classe cChartOperations { pubblico: cChartOperations(int larghezza, int altezza) { // ... } nulla Su clic(int x, int y) { // ... } nulla OnChartChange() { // ... } privato: int Chart_width; int Chart_height; uint Last_click; int Last_click_x, Last_click_y; bool IsDoubleClick(int x, int y) { // ... } };

Ogni classe ha un costruttore, che in pratica è una funzione chiamata automaticamente quando viene creato l'oggetto. Il costruttore ha lo stesso nome dell'oggetto e può assumere parametri. Nel nostro frammento di codice sopra, creiamo un costruttore come segue:

cChartOperations(int larghezza, int altezza) { }

Dopo aver creato il costruttore, possiamo definire i componenti della classe, cioè funzioni e variabili. Sono definiti esattamente come nel caso di funzioni e variabili ordinarie con la differenza che nel corpo della classe. Presta attenzione alle tue parole chiave pubblico: e privato:. Tutte le funzioni e le variabili che si trovano dopo la parola pubblico: sarà disponibile per funzioni che si trovano in altre parti del software, ad esempio nella funzione API OnTick () o altri oggetti. Privati tuttavia, informa il compilatore che gli elementi definiti in questa parte sono strettamente confidenziali e che nessuno, a parte un determinato oggetto, ha naturalmente accesso ad essi.

Applicazioni di oggetti

Cosa crea oggetti così utili? Tra l'altro, è possibile che una volta definito l'oggetto possa essere creato in un numero qualsiasi di copie e, a seconda dei parametri passati a loro, si comporteranno in modo diverso, ma in un modo che siamo in grado di analizzare e controllare. Inoltre, gli oggetti consentono l'organizzazione leggibile del codice dividendo i componenti dell'algoritmo in elementi estratti e un oggetto progettato correttamente può essere utilizzato in un software completamente diverso, che consente di creare in modo efficace applicazioni complesse.


esperti consulenti


Iniziamo il primo oggetto

Passiamo al file principale del nostro software, file AlgoTrader_v10.mq4che troverai nel catalogo MQL4 \ Esperti \.

Diamo un'occhiata alla definizione dell'API di seguito OnInit ():

cChartOperations* ChartOperations = NULL; int OnInit() { // (...) int chart_width = (int)ChartGetInteger(0, CHART_WIDTH_IN_PIXELS); int chart_height = (int)ChartGetInteger(0, CHART_HEIGHT_IN_PIXELS); ChartOperations = nuovo cChartOperations(chart_width, chart_height); ritorno(INIT_SUCCEEDED); }

Pointer

Nella parte del file responsabile della definizione delle variabili globali mediante lo snippet di codice ...

cChartOperations* ChartOperations = NULL;

... creiamo i cosiddetti pointer cioè, un puntatore che conterrà un indirizzo in una posizione nella memoria del computer, dove il nostro oggetto verrà creato in seguito. Usando il puntatore potremo fare riferimento all'oggetto e richiamarne le funzioni. puntatori definiamo in modo simile alle variabili, il primo elemento della notazione è il tipo di oggetto, quindi posizioniamo l'asterisco * , dopo di che impostiamo un nome univoco per l'oggetto, che utilizzeremo in seguito per i riferimenti. Alla nostra pointer assegniamo una variabile NULL, che dice che allo stato attuale non indica ancora alcun oggetto.

costruttore

Più tardi nel codice, nel corpo della funzione OnInit () creiamo l'oggetto giusto usando una parola chiave nuovo.

ChartOperations = nuovo cChartOperations(chart_width, chart_height);

Po nuovo chiamiamo il costruttore dell'oggetto, che nel nostro caso prende due variabili che informano l'oggetto sulle dimensioni del nostro grafico, perché ne abbiamo bisogno per posizionare correttamente la nostra interfaccia. Il costruttore chiamato inoltra l'indirizzo dell'oggetto appena creato nella memoria del computer al nostro pointer detto ChartOperations.

distruttore

Gli oggetti sono un tipo speciale di dati, che se lo creiamo, dobbiamo assicurarci che sia finalmente rimosso dalla memoria del computer. Tutto questo in modo che davanti al tuo laptop non sia necessario essere un server enorme che raccoglie dati creati in precedenza che non sono più necessari a nessuno.

Per eliminare oggetti, usiamo la parola chiave delete, dopo di che abbiamo posto il nostro nome poinera indicando quale oggetto intendiamo. Rimuoviamo il nostro oggetto solo nella funzione API OnDeinit (...)perché ne abbiamo bisogno per tutto il ciclo di vita dell'applicazione, fino a quando il software non viene spento.

nulla OnDeinit(const int ragione) { // (...) delete ChartOperations; }

Lavora con gli oggetti

Vediamo ora come possiamo usare il nostro oggetto creato per le esigenze della nostra applicazione. Per questo scopo nel corpo della classe cChartOperations Abbiamo definito diverse funzioni. Diamo un'occhiata a uno di loro:

nulla Su clic(int x, int y) { if(IsDoubleClick(x, y)) GoToPrice(x, y); }

funzione OnClick (...) ne abbiamo bisogno per comunicare alla nostra interfaccia quali livelli di prezzo sono attualmente interessanti per noi. Facendo doppio clic sul grafico, l'algoritmo imposterà la nostra scala dei prezzi nel luogo indicato. Per far funzionare la nostra funzione, dobbiamo rilevare il momento in cui clicchiamo sul grafico, e qui la funzione API aiuta OnChartEvent (...)

nulla OnChartEvent(const int id const lungo & lParam const doppio & Dparam, const stringa & Spare) { // (...) if(id == CHARTEVENT_CLICK) ChartOperations.OnClick((int)lParam (int)dparam); }

Lo snippet di codice sopra riportato riconosce il momento in cui l'utente fa clic sul grafico e quindi chiama la funzione che si trova all'interno dell'oggetto creato in precedenza. Chiamare una funzione consiste nel posizionare un punto dopo il nostro nome pointer all'oggetto, quindi passando il nome della funzione a cui siamo interessati insieme ai parametri necessari, che nel nostro caso indicano le coordinate xey del luogo nel grafico in cui è stato fatto il clic.

Primi effetti

Le procedure da noi create hanno lanciato la prima funzionalità del software, che possiamo testare compilando il nostro programma e facendo clic su un grafico diverso. Di seguito troverai un grafico che presenta alcune funzioni che ti permettono di manipolare i livelli di prezzo visualizzati nella nostra interfaccia grafica.

programmazione mql

Mouse e livelli di prezzo

Seconda classe

Dato che sei stato promosso alla seconda elementare e il nostro clic non va sprecato, progetteremo una seconda struttura che ti consentirà di effettuare ordini dal livello della nostra scala. A tale scopo, abbiamo preparato la classe appropriata, che troverai nel file MQL4 \ Include \ AlgoTrader_v10 \ OrderOperations.mqh

classe cOrderOperations { pubblico: cOrderOperations(int position_id) { Position_id = position_id; } nulla OnTimer200ms() { ProcessOrderRequests(); } privato: int Position_id; nulla ProcessOrderRequests() { sOrderRequest richiesta = ReadOrderRequest(); if(request.Request_id <= 0) ritorno; if(request.Order_symbol != Simbolo() || request.Position_id != Position_id) { request.Request_status = ORDER_REQUEST_STATUS_FAILED; request.Request_error = ORDER_REQUEST_ERROR_WRONG_POSITION; ritorno; } if(OrderSend(request.Order_symbol, request.Order_type, request.Order_volume, request.Order_price, 0, 0, 0, request.Order_comment, request.Position_id) > 0) { request.Request_status = ORDER_REQUEST_STATUS_COMPLETED; } altro { request.Request_status = ORDER_REQUEST_STATUS_FAILED; request.Request_error = _LastError; } UpdateOrderRequest(richiesta); } };

Nel codice sopra puoi vedere la definizione completa dell'oggetto cOrderOperationsche verrà utilizzato per gestire gli ordini che inseriremo nella nostra scala dei prezzi. Prestare attenzione alla funzione ProcessOrderRequests ()in cui il nostro programma comunica con la biblioteca dll usando la funzione ReadOrderRequest ().

strutture

funzione ReadOrderRequest () come risultato della sua azione restituisce una struttura di tipo sOrderRequest, che è un insieme di dati da noi definiti con un ordine effettuato tramite l'interfaccia.

nulla ProcessOrderRequests() { sOrderRequest richiesta = ReadOrderRequest(); // (...) }

Le strutture sono sorelle più giovani di classi che consentono di creare un blocco di dati contenente molte variabili. Ciò consente l'ordinamento logico delle informazioni relative a un determinato problema. Nel nostro caso, la struttura raccoglie dati sull'ordine inviato dalla nostra interfaccia grafica, come il prezzo di apertura o il volume. Definiamo una struttura precedendo il suo nome con una parola chiave structe quindi impostiamo un elenco dei dati di cui abbiamo bisogno.

struct sOrderRequest { int request_id; int Position_id; int ORDER_TYPE; doppio Order_volume; doppio Order_price; doppio Order_range; stringa Order_symbol; stringa Order_comment; int Request_status; int Request_error; };

La definizione sopra può essere trovata nel file MQL4 \ Include \ AlgoTrader_v10 \ Definitions.mqh.

Usiamo le strutture in modo simile alle variabili, nel primo passo abbiamo bisogno di crearlo specificando il tipo di struttura, e quindi dargli un nome univoco, al quale possiamo riferirci in seguito. Nell'esempio seguente, creiamo una struttura di tipo sOrderRequest e gli diamo un nome unico richiestae quindi assegniamo i dati dalla nostra interfaccia usando le funzioni ReadOrderRequest ().

nulla ProcessOrderRequests() { sOrderRequest richiesta = ReadOrderRequest(); // (...) }

L'accesso ai dati memorizzati nella struttura è analogo all'utilizzo di variabili, perché in pratica la struttura è solo un insieme di variabili nascoste sotto un identificatore comune. Per leggere o scrivere dati nella struttura è sufficiente dopo il nome che abbiamo dato per mettere un punto, e quindi indicare il nome della variabile che ci interessa. Nel seguente frammento del codice, leggiamo i dati memorizzati nella struttura per inviare l'ordine e quindi salviamo le informazioni sul risultato dell'operazione.

if(OrderSend(request.Order_symbol, request.Order_type, request.Order_volume, request.Order_price, 0, 0, 0, request.Order_comment, request.Position_id) > 0) { request.Request_status = ORDER_REQUEST_STATUS_COMPLETED; }

Esecuzione di ordini

Affinché il nostro software possa inviare ordini, dobbiamo implementare l'oggetto creato sulla base della classe cOrderOperations. Poiché avremo bisogno dell'oggetto dal lancio del nostro programma, lo creiamo nella funzione API OnInit ().

ingresso int Position_id = 8821; // L'identificativo univoco dell'articolo cOrderOperations* OrderOperations = NULL; int OnInit() { EventSetMillisecondTimer(200); // (...) OrderOperations = nuovo cOrderOperations(Position_id); ritorno(INIT_SUCCEEDED); }

Nel costruttore cOrderOperations poniamo una variabile Position_id, che fa parte delle impostazioni della nostra applicazione disponibile nella finestra della piattaforma MetaTrader predefinita. L'identificatore consente al nostro software di riconoscere i propri ordini in modo tale da non creare confusione con gli ordini provenienti da altre fonti.

Abbiamo anche lanciato il codice sopra Timer con l'intervallo ms 200, poiché il nostro oggetto dovrebbe controllare periodicamente se l'interfaccia invia informazioni sull'ordine in entrata.

nulla OnTimer() { // (...) OrderOperations.OnTimer200ms(); }

La funzione dell'oggetto OnTimer200ms () chiamerà una funzione ProcessOrderRequests ()chi effettuerà l'ordine quando riceverà i dati appropriati dall'interfaccia.

classe cOrderOperations { pubblico: cOrderOperations(int position_id) { Position_id = position_id; } nulla OnTimer200ms() { ProcessOrderRequests(); } // (...) };

effetti

Il nostro software può già comunicare con l'interfaccia grafica e possiamo fare ciò che ci piace fare di più, cioè compilare l'algoritmo e inviare un nuovo ordine. Per aiutarti a iniziare i primi passaggi seguenti troverai alcuni suggerimenti che illustrano quali funzioni sono nascoste sotto chiavi diverse.

Controllo del volume

volume di trading forex

Supporto per il volume

Tipi di ordini

algo trading

Gestione degli ordini

Somma

È tutto per oggi, ma questo è solo l'inizio dell'avventura con Algo Trader. Nel prossimo episodio, andremo a implementare funzioni avanzate relative al supporto dell'algoritmo. Algo Trader verrà creato insieme a te e saremo grati per qualsiasi idea e commento che possa renderlo migliore per te. Siamo felici di sentirti all'indirizzo biuro@expertadvisors.pl .

Cosa ne pensi?
Io
63%
interessante
25%
Eh ...
13%
Cosa?
0%
Non mi piace
0%
Tragedia
0%
Circa l'autore
Radek Szafron
Radek Szafron
L'autore della pubblicazione è Radek Szafron, proprietario della società Expert Advisors, che da anni supporta gli investitori fornendo tecnologie dedicate al mercato FOREX. L'autore si è laureato alla Warsaw School of Economics con la specializzazione "Mercati finanziari" e un programmatore con quasi l'esperienza estiva 20. La società implementa progetti di algoritmi e applicazioni scritte in tutte le lingue dalla famiglia "C", comprese le piattaforme popolari Meta Trader 4 e 5. I consulenti esperti possono essere trovati su www.expertadvisors.pl.

Lascia una risposta