iCustom in MQL5:
Chiamare Indicatori Esterni
da EA e Indicatori — Guida Completa

// SCHEMA GENERALE (da implementare sempre così)

// 1. Dichiarazione globale dell'handle
int handleMioIndicatore = INVALID_HANDLE;

// 2. Creazione dell'handle in OnInit()
int OnInit()
{
    handleMioIndicatore = iCustom(_Symbol, PERIOD_H4, "MioIndicatore");
    
    if(handleMioIndicatore == INVALID_HANDLE)
    {
        Print("ERRORE: iCustom fallito. Codice: ", GetLastError());
        return(INIT_FAILED);
    }
    
    return(INIT_SUCCEEDED);
}

// 3. Lettura del buffer con CopyBuffer in OnTick() o OnCalculate()
void OnTick()
{
    double valori[];
    ArraySetAsSeries(valori, true);
    
    if(CopyBuffer(handleMioIndicatore, 0, 0, 3, valori) <= 0)
    {
        Print("ERRORE CopyBuffer: ", GetLastError());
        return;
    }
    
    double valoreBarra0 = valori[0];  // barra corrente
    double valoreBarra1 = valori[1];  // barra precedente
    double valoreBarra2 = valori[2];  // due barre fa
}

// 4. Rilascio dell'handle in OnDeinit()
void OnDeinit(const int reason)
{
    if(handleMioIndicatore != INVALID_HANDLE)
        IndicatorRelease(handleMioIndicatore);
}

int iCustom(
    string       symbol,     // simbolo: usa _Symbol per il corrente
    ENUM_TIMEFRAMES timeframe, // timeframe: PERIOD_H4, PERIOD_D1, etc.
    string       name,       // nome del file .ex5 SENZA l'estensione
    ...                       // parametri dell'indicatore (opzionali, variabili)
);

// ESEMPI DI CHIAMATA:

// Indicatore senza parametri aggiuntivi
int h1 = iCustom(_Symbol, PERIOD_H4, "MioIndicatore");

// Indicatore con 1 parametro intero (es. periodo)
int h2 = iCustom(_Symbol, PERIOD_H4, "UlcerIndex", 14);

// Indicatore con più parametri di tipi diversi
int h3 = iCustom(_Symbol, PERIOD_H4, "ZenithScore",
                   14,        // int: periodo UI
                   2.0,       // double: moltiplicatore ATR
                   true,      // bool: abilita filtro sessione
                   "XAUUSD"   // string: simbolo correlazione
           );

// Indicatore su simbolo diverso da quello corrente
int h4 = iCustom("EURUSD", PERIOD_H4, "MioIndicatore", 14);

// Indicatore su timeframe diverso (lettura multi-TF)
int h5 = iCustom(_Symbol, PERIOD_D1, "MioIndicatore", 14);
         // Legge l'indicatore sul Daily anche se il chart è H4

// Pattern completo per gestione robusta degli handle
// usato in Oracle v78 per i suoi 6 handle di indicatori

// Dichiarazione globale — inizializza SEMPRE a INVALID_HANDLE
int hUlcer   = INVALID_HANDLE;
int hATR     = INVALID_HANDLE;
int hSession = INVALID_HANDLE;

int OnInit()
{
    // Crea tutti gli handle in sequenza
    hUlcer   = iCustom(_Symbol, PERIOD_H4, "UlcerZenith_v77", 14, true);
    hATR     = iATR(_Symbol, PERIOD_H4, 14);
    hSession = iCustom(_Symbol, PERIOD_H4, "SessionFilter");
    
    // Verifica TUTTI prima di procedere
    if(hUlcer == INVALID_HANDLE || hATR == INVALID_HANDLE || hSession == INVALID_HANDLE)
    {
        PrintFormat("OnInit FAILED: hUlcer=%d hATR=%d hSession=%d err=%d",
                     hUlcer, hATR, hSession, GetLastError());
        RilasciaHandles();  // rilascia quelli eventualmente validi
        return(INIT_FAILED);
    }
    
    // Attesa warm-up: aspetta che gli indicatori abbiano dati calcolati
    // Specialmente importante su simboli appena aperti o dati scarsi
    EventSetTimer(1);  // controlla ogni secondo in OnTimer()
    
    return(INIT_SUCCEEDED);
}

void RilasciaHandles()
{
    // Helper function — rilascia solo gli handle validi
    if(hUlcer   != INVALID_HANDLE) { IndicatorRelease(hUlcer);   hUlcer   = INVALID_HANDLE; }
    if(hATR     != INVALID_HANDLE) { IndicatorRelease(hATR);     hATR     = INVALID_HANDLE; }
    if(hSession != INVALID_HANDLE) { IndicatorRelease(hSession); hSession = INVALID_HANDLE; }
}

void OnDeinit(const int reason)
{
    EventKillTimer();
    RilasciaHandles();
}

// Verifica che i dati siano disponibili prima di usarli
bool DatiPronti()
{
    return(
        BarsCalculated(hUlcer)   >= 50 &&
        BarsCalculated(hATR)     >= 14 &&
        BarsCalculated(hSession) >= 1
    );
}

// VARIANTE 1: copia N elementi partendo dalla barra start_pos
// (la più usata)
int CopyBuffer(
    int    indicator_handle,  // handle dell'indicatore
    int    buffer_num,        // indice del buffer (0 = primo buffer)
    int    start_pos,         // barra da cui iniziare (0 = più recente)
    int    count,             // numero di elementi da copiare
    double& buffer[]          // array di destinazione
);

// VARIANTE 2: copia N elementi a partire da un datetime specifico
int CopyBuffer(
    int      indicator_handle,
    int      buffer_num,
    datetime start_time,    // datetime di inizio
    int      count,
    double&  buffer[]
);

// VARIANTE 3: copia tra due datetime
int CopyBuffer(
    int      indicator_handle,
    int      buffer_num,
    datetime start_time,
    datetime stop_time,
    double&  buffer[]
);

// ═══════════════════════════════════════════════════════════
// ESEMPI PRATICI
// ═══════════════════════════════════════════════════════════

double buf[];
ArraySetAsSeries(buf, true);  // indice 0 = barra più recente

// Leggi solo la barra corrente (più efficiente quando serve solo 1 valore)
double valoreSingolo[1];
CopyBuffer(hUlcer, 0, 0, 1, valoreSingolo);
// valoreSingolo[0] = valore Ulcer Index sulla barra più recente

// Leggi le ultime 3 barre (per confrontare valori recenti)
CopyBuffer(hUlcer, 0, 0, 3, buf);
// buf[0] = barra corrente, buf[1] = precedente, buf[2] = due fa

// Leggi dal secondo buffer dell'indicatore (indice 1)
double segnaleBuf[];
CopyBuffer(hUlcer, 1, 0, 3, segnaleBuf);

// Leggi le ultime 200 barre per calcolo statistico
ArrayResize(buf, 200);
int copied = CopyBuffer(hUlcer, 0, 0, 200, buf);
if(copied != 200)
    Print("Solo ", copied, " barre disponibili (richieste 200)");

// Leggi i dati dell'ultima settimana con range datetime
datetime unaSettimanaFa = TimeCurrent() - 7 * 86400;
CopyBuffer(hUlcer, 0, unaSettimanaFa, TimeCurrent(), buf);

// Funzione helper che gestisce tutti gli errori di CopyBuffer
bool LeggiBuffer(int handle, int bufferIdx, int count, double &out[])
{
    if(handle == INVALID_HANDLE) return(false);
    
    ArraySetAsSeries(out, true);
    int copied = CopyBuffer(handle, bufferIdx, 0, count, out);
    
    if(copied <= 0)
    {
        int err = GetLastError();
        switch(err)
        {
            case ERR_INDICATOR_DATA_NOT_FOUND:
                // I dati non sono ancora calcolati — normale all'avvio
                return(false);
            case ERR_HISTORY_NOT_FOUND:
                // Non ci sono abbastanza dati storici
                Print("Dati storici insufficienti per buffer ", bufferIdx);
                return(false);
            default:
                PrintFormat("CopyBuffer errore %d su handle %d buffer %d",
                             err, handle, bufferIdx);
                return(false);
        }
    }
    
    if(copied < count)
    {
        // Meno dati del richiesto — non necessariamente un errore
        // (es. il grafico ha meno barre di quante richieste)
        Print("CopyBuffer: ricevute ", copied, " barre su ", count, " richieste");
    }
    
    return(true);
}

// INDICATORE TARGET (UlcerZenith_v77.mq5) — parametri input:
// input int    PeriodoUI        = 14;     // periodi per il calcolo UI
// input double MoltiplicatoreATR = 2.0;  // ATR multiplier per lo stop
// input bool   FiltroSessione   = true;  // abilita filtro sessione
// input ENUM_TIMEFRAMES TFConfermta = PERIOD_D1; // TF di conferma

// CHIAMATA CORRETTA — tipi e ordine devono corrispondere esattamente
int hZenith = iCustom(_Symbol, PERIOD_H4, "UlcerZenith_v77",
    (int)    14,           // ✓ int → int
    (double) 2.0,          // ✓ double → double
    (bool)   true,         // ✓ bool → bool
    (int)    PERIOD_D1     // ✓ int (enum) → ENUM_TIMEFRAMES
);

// ERRORI COMUNI:

// ✗ Passare 14 (int) dove si aspetta double
int hErrato1 = iCustom(_Symbol, PERIOD_H4, "UlcerZenith_v77",
    14,     // OK (int literal)
    2,      // ✗ int literal dove serve double → dati SBAGLIATI in silenzio!
    true,
    PERIOD_D1
);
// Fix: usa 2.0 (double literal) o (double)2

// ✗ Saltare un parametro
int hErrato2 = iCustom(_Symbol, PERIOD_H4, "UlcerZenith_v77",
    14, 2.0  // ✗ mancano filtroSessione e TFConferma
             // usa i default dell'indicatore — ma potrebbe produrre
             // INVALID_HANDLE se i tipi successivi non corrispondono
);
// Fix: passa TUTTI i parametri o usa i default espliciti

// ✓ Uso di variabili parametrizzate (pattern EA con input)
input int    InpPeriodoUI        = 14;
input double InpMoltiplicatoreATR = 2.0;
input bool   InpFiltroSessione   = true;

int hCorretto = iCustom(_Symbol, PERIOD_H4, "UlcerZenith_v77",
    InpPeriodoUI, InpMoltiplicatoreATR, InpFiltroSessione, PERIOD_D1
);

// Struttura per raccogliere tutti i valori di UlcerZenith in una barra
struct ZenithData
{
    double score;       // buffer 0: score 0-10
    double direzione;   // buffer 1: +1 long, -1 short, 0 neutro
    double entryLevel;  // buffer 2: livello prezzo suggerito per entry
    double band68;      // buffer 3: banda T-Student al 68%
    double band95;      // buffer 4: banda T-Student al 95%
    double band99;      // buffer 5: banda T-Student al 99%
    double ulcerRaw;    // buffer 6: valore grezzo Ulcer Index
    double atrAdattivo; // buffer 7: ATR adattivo corrente
};

bool LeggiZenith(ZenithData &dati, int barra = 0)
{
    double tmp[1];
    
    // Leggi ogni buffer separatamente (approccio più sicuro)
    if(CopyBuffer(hZenith, 0, barra, 1, tmp) <= 0) return(false);
    dati.score = tmp[0];
    
    if(CopyBuffer(hZenith, 1, barra, 1, tmp) <= 0) return(false);
    dati.direzione = tmp[0];
    
    if(CopyBuffer(hZenith, 2, barra, 1, tmp) <= 0) return(false);
    dati.entryLevel = tmp[0];
    
    if(CopyBuffer(hZenith, 3, barra, 1, tmp) <= 0) return(false);
    dati.band68 = tmp[0];
    
    if(CopyBuffer(hZenith, 4, barra, 1, tmp) <= 0) return(false);
    dati.band95 = tmp[0];
    
    if(CopyBuffer(hZenith, 5, barra, 1, tmp) <= 0) return(false);
    dati.band99 = tmp[0];
    
    if(CopyBuffer(hZenith, 6, barra, 1, tmp) <= 0) return(false);
    dati.ulcerRaw = tmp[0];
    
    if(CopyBuffer(hZenith, 7, barra, 1, tmp) <= 0) return(false);
    dati.atrAdattivo = tmp[0];
    
    return(true);
}

// Uso in OnTick
ZenithData zenith;
if(!LeggiZenith(zenith))
{
    Print("Dati Zenith non disponibili");
    return;
}

PrintFormat("Score: %.2f | Dir: %+.0f | Entry: %.5f | Band95: %.5f",
             zenith.score, zenith.direzione, zenith.entryLevel, zenith.band95);

// Pattern ottimizzato: leggi solo su nuova barra
static datetime ultimaBarra = 0;
static double   zenithScore  = 0.0;   // cache del valore

void OnTick()
{
    datetime barraCorrT = iTime(_Symbol, PERIOD_H4, 0);
    if(barraCorrT == ultimaBarra) return;  // stessa barra, esci subito
    ultimaBarra = barraCorrT;
    
    // Nuova barra H4: leggi i buffer
    double buf[2];
    ArraySetAsSeries(buf, true);
    if(CopyBuffer(hZenith, 0, 1, 2, buf) < 2) return; // legge barre chiuse
    
    // Nota: start_pos=1 per leggere barra 1 e barra 2 (entrambe chiuse)
    // Evita la barra 0 che è ancora aperta e potrebbe avere dati parziali
    zenithScore = buf[0];   // barra 1 (chiusa più recente)
    
    // Processa il segnale...
    if(zenithScore >= 7.0) ConsideraSegnaleLong();
    else if(zenithScore <= 3.0) ConsideraSegnaleShort();
}

// ZenithExecutor.mq5 — sezione rilevante per iCustom
// (semplificata per illustrare il pattern)

input string InpNomeIndicatore = "MTInvestments\\UlcerZenith_v77";
input int    InpPeriodoUI       = 14;
input double InpScoreMinLong    = 7.0;
input double InpScoreMaxShort   = 3.0;

int hZenith = INVALID_HANDLE;

int OnInit()
{
    // Crea handle con parametri identici a quelli dell'indicatore sul chart
    hZenith = iCustom(_Symbol, PERIOD_H4, InpNomeIndicatore,
                      InpPeriodoUI,   // parametro 1: periodo
                      2.0,            // parametro 2: moltiplicatore ATR
                      true,           // parametro 3: filtro sessione
                      PERIOD_D1       // parametro 4: TF conferma
    );
    
    if(hZenith == INVALID_HANDLE)
    {
        Alert("Errore creazione handle UlcerZenith. File presente in Indicators?");
        return(INIT_FAILED);
    }
    
    // Attendi che l'indicatore abbia almeno 50 barre calcolate
    int tentativi = 0;
    while(BarsCalculated(hZenith) < 50 && tentativi < 100)
    {
        Sleep(100);  // aspetta 100ms
        tentativi++;
    }
    
    if(BarsCalculated(hZenith) < 50)
    {
        Print("UlcerZenith non ha dati sufficienti dopo warm-up");
        return(INIT_FAILED);
    }
    
    Print("ZenithExecutor inizializzato. Handle: ", hZenith,
          " Barre calcolate: ", BarsCalculated(hZenith));
    return(INIT_SUCCEEDED);
}

// Script MQL5 per diagnosticare problemi con iCustom
// Incolla in uno script e premi F5 per eseguire

void OnStart()
{
    string nomeIndicatore = "MTInvestments\\UlcerZenith_v77";
    
    // Test 1: il file esiste?
    Print("=== Test iCustom Diagnostica ===");
    
    int h = iCustom(_Symbol, PERIOD_H4, nomeIndicatore, 14, 2.0, true, PERIOD_D1);
    PrintFormat("Handle: %d (INVALID=%d)", h, INVALID_HANDLE);
    
    if(h == INVALID_HANDLE)
    {
        PrintFormat("FALLITO. Errore: %d. Verifica:", GetLastError());
        Print("1. File esiste in MQL5/Indicators/", nomeIndicatore, ".ex5?");
        Print("2. Il file è compilato (verde in Navigator)?");
        Print("3. I parametri corrispondono in tipo e ordine?");
        return;
    }
    
    // Test 2: quante barre calcolate?
    Sleep(2000);  // aspetta 2 secondi per il calcolo
    int barre = BarsCalculated(h);
    PrintFormat("Barre calcolate: %d", barre);
    
    // Test 3: leggi i primi 3 valori di ogni buffer
    for(int buf = 0; buf < 8; buf++)
    {
        double vals[3];
        int copied = CopyBuffer(h, buf, 0, 3, vals);
        if(copied <= 0)
            PrintFormat("Buffer %d: ERRORE (copied=%d err=%d)", buf, copied, GetLastError());
        else
            PrintFormat("Buffer %d: [%.4f, %.4f, %.4f]", buf, vals[0], vals[1], vals[2]);
    }
    
    IndicatorRelease(h);
    Print("=== Fine diagnostica ===");
}