Programación en MQL5 (IV)

//+------------------------------------------------------------------+
//| Indicador SMA con Dos Líneas                                     |
//+------------------------------------------------------------------+
#property indicator_chart_window // Dibuja el indicador en la ventana del gráfico principal
#property indicator_buffers 2    // Usamos 2 buffers para almacenar los valores de las dos SMAs
#property indicator_color1 Blue  // Color de la línea del SMA rápido
#property indicator_color2 Red   // Color de la línea del SMA lento

// Parámetros de entrada
input int FastMAPeriod = 10; // Período del SMA rápido
input int SlowMAPeriod = 50; // Período del SMA lento

// Buffers
double fastMABuffer[]; // Buffer para almacenar los valores del SMA rápido
double slowMABuffer[]; // Buffer para almacenar los valores del SMA lento

// Función de inicialización
int OnInit() {
   // Asignar los buffers a sus respectivos índices
   SetIndexBuffer(0, fastMABuffer); // Buffer 0 para el SMA rápido
   SetIndexBuffer(1, slowMABuffer); // Buffer 1 para el SMA lento

   // Configurar nombres cortos para las líneas
   IndicatorShortName("SMA Rápido (" + IntegerToString(FastMAPeriod) + ") | SMA Lento (" + IntegerToString(SlowMAPeriod) + ")");
   return(INIT_SUCCEEDED);
}

// Función principal que se ejecuta en cada tick
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[]) {
   // Calcular el SMA rápido
   for (int i = prev_calculated; i < rates_total; i++) {
      double sumFast = 0;
      for (int j = 0; j < FastMAPeriod; j++) {
         sumFast += close[i - j];
      }
      fastMABuffer[i] = sumFast / FastMAPeriod; // Almacenar el valor en el buffer del SMA rápido
   }

   // Calcular el SMA lento
   for (int i = prev_calculated; i < rates_total; i++) {
      double sumSlow = 0;
      for (int j = 0; j < SlowMAPeriod; j++) {
         sumSlow += close[i - j];
      }
      slowMABuffer[i] = sumSlow / SlowMAPeriod; // Almacenar el valor en el buffer del SMA lento
   }

   return(rates_total);
}

//+------------------------------------------------------------------+
//| EA basado en el cruce de SMA rápido y lento                      |
//+------------------------------------------------------------------+
#property strict

// Parámetros de entrada
input int FastMAPeriod = 10; // Período del SMA rápido
input int SlowMAPeriod = 50; // Período del SMA lento
input double LotSize = 0.1;  // Tamaño de lote

// Variables globales
double fastMA, slowMA;

// Función principal que se ejecuta en cada tick
void OnTick() {
   // Obtener los valores actuales del indicador SMA modificado
   fastMA = iCustom(_Symbol, _Period, "SMA_Dos_Líneas", FastMAPeriod, SlowMAPeriod, 0, 0); // Valor actual del SMA rápido
   slowMA = iCustom(_Symbol, _Period, "SMA_Dos_Líneas", FastMAPeriod, SlowMAPeriod, 1, 0); // Valor actual del SMA lento

   // Verificar si hay posiciones abiertas
   if (PositionsTotal() == 0) {
      // Abrir posición larga si el SMA rápido cruza por encima del lento
      if (fastMA > slowMA) {
         OpenBuyPosition();
      }
      // Abrir posición corta si el SMA rápido cruza por debajo del lento
      else if (fastMA < slowMA) {
         OpenSellPosition();
      }
   } else {
      // Cerrar posición si las medias móviles cruzan en sentido contrario
      CloseOpenPosition();
   }
}

// Función para abrir una posición larga
void OpenBuyPosition() {
   double stopLoss = NormalizeDouble(Ask - 50 * Point(), _Digits); // Stop loss a 50 pips
   double takeProfit = NormalizeDouble(Ask + 100 * Point(), _Digits); // Take profit a 100 pips

   if (OrderSend(_Symbol, OP_BUY, LotSize, Ask, 10, stopLoss, takeProfit)) {
      Print("Posición larga abierta. Precio: ", DoubleToString(Ask, _Digits));
   } else {
      Print("Error al abrir posición larga. Código de error: ", GetLastError());
   }
}

// Función para abrir una posición corta
void OpenSellPosition() {
   double stopLoss = NormalizeDouble(Bid + 50 * Point(), _Digits); // Stop loss a 50 pips
   double takeProfit = NormalizeDouble(Bid - 100 * Point(), _Digits); // Take profit a 100 pips

   if (OrderSend(_Symbol, OP_SELL, LotSize, Bid, 10, stopLoss, takeProfit)) {
      Print("Posición corta abierta. Precio: ", DoubleToString(Bid, _Digits));
   } else {
      Print("Error al abrir posición corta. Código de error: ", GetLastError());
   }
}

// Función para cerrar la posición abierta
void CloseOpenPosition() {
   for (int i = 0; i < PositionsTotal(); i++) {
      uint ticket = PositionGetTicket(i);
      int type = PositionGetInteger(POSITION_TYPE);

      if (type == POSITION_TYPE_BUY && fastMA < slowMA) {
         OrderClose(ticket, PositionGetDouble(POSITION_VOLUME), Bid, 10);
         Print("Posición larga cerrada.");
      } else if (type == POSITION_TYPE_SELL && fastMA > slowMA) {
         OrderClose(ticket, PositionGetDouble(POSITION_VOLUME), Ask, 10);
         Print("Posición corta cerrada.");
      }
   }
}

Posición larga abierta. Precio: 1.23456

Posición corta abierta. Precio: 1.23000

Posición larga cerrada.

//+------------------------------------------------------------------+
//| Indicador de Soporte y Resistencia Dinámica                      |
//+------------------------------------------------------------------+
#property indicator_chart_window // Dibuja el indicador en la ventana del gráfico principal
#property indicator_buffers 2    // Usamos 2 buffers para almacenar los valores de soporte y resistencia
#property indicator_color1 Green // Color de la línea de soporte (verde)
#property indicator_color2 Red   // Color de la línea de resistencia (rojo)

// Parámetros de entrada
input int LookbackPeriod = 20; // Número de barras para calcular soporte y resistencia

// Buffers
double supportBuffer[]; // Buffer para almacenar los valores de soporte
double resistanceBuffer[]; // Buffer para almacenar los valores de resistencia

// Función de inicialización
int OnInit() {
   // Asignar los buffers a sus respectivos índices
   SetIndexBuffer(0, supportBuffer); // Buffer 0 para el soporte
   SetIndexBuffer(1, resistanceBuffer); // Buffer 1 para la resistencia

   // Configurar nombres cortos para las líneas
   IndicatorShortName("Soporte (" + IntegerToString(LookbackPeriod) + ") | Resistencia (" + IntegerToString(LookbackPeriod) + ")");
   return(INIT_SUCCEEDED);
}

// Función principal que se ejecuta en cada tick
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[]) {
   // Calcular soporte y resistencia dinámicos
   for (int i = prev_calculated; i < rates_total; i++) {
      // Calcular el precio mínimo (soporte) de las últimas LookbackPeriod barras
      double minPrice = low[i];
      for (int j = 1; j < LookbackPeriod && (i - j) >= 0; j++) {
         if (low[i - j] < minPrice) {
            minPrice = low[i - j];
         }
      }
      supportBuffer[i] = minPrice; // Almacenar el valor en el buffer de soporte

      // Calcular el precio máximo (resistencia) de las últimas LookbackPeriod barras
      double maxPrice = high[i];
      for (int j = 1; j < LookbackPeriod && (i - j) >= 0; j++) {
         if (high[i - j] > maxPrice) {
            maxPrice = high[i - j];
         }
      }
      resistanceBuffer[i] = maxPrice; // Almacenar el valor en el buffer de resistencia
   }

   return(rates_total);
}