Por favor, ayude a escribir EAs de forma gratuita. 5 ideas diferentes. - página 15
Está perdiendo oportunidades comerciales:
- Aplicaciones de trading gratuitas
- 8 000+ señales para copiar
- Noticias económicas para analizar los mercados financieros
Registro
Entrada
Usted acepta la política del sitio web y las condiciones de uso
Si no tiene cuenta de usuario, regístrese
Eso es todo. Ya veo. "Tratando" de ayudar. Creo que es hora de compartir algunas ideas más.
Eso es todo. Ya veo. "Tratando" de ayudar. Creo que es hora de compartir algunas ideas más.
¿A quién le interesa la "vieja bicicleta"? Todavía no has entendido que lo que intentas empezar a explorar hace tiempo que está en el foro y que hay implementaciones gratuitas en la base de código - busca y juega. ¿Tienes tus propias ideas? Por lo demás, no hay nada que discutir.
¡Ayúdeme a agregar el número máximo de órdenes abiertas al asesor!
//+-------------------------------------------------------- --------------------+
//| v128-2.mq4 |
//| Copyright © 2011, Andrey N. Bolkonsky |
//| 21/03/2011 |
//| correo electrónico: abolk@yandex.ru | Skype: abolk1 |
//+-------------------------------------------------------- --------------------+
#property copyright "Copyright © 2011, Andrey N. Bolkonsky"
#enlace de propiedad "abolk@yandex.ru"
//
extern string rem2 = "=== Número de lotes ===";
doble externo _Lotes0_1 = 0.1; // Nivel base (para el 1er pedido)
doble externo _Lotes0_2 = 0.1; // Nivel base (para el segundo orden)
//
cadena externa rem3 = "=== Parámetros adicionales ===";
externo int _TakeProfit1_Proc = 50; // Porcentaje de riesgo para tomar ganancias de la 1ra orden
externo int _SpaseFromMaxMin = 1; // Desplazamiento desde arriba/abajo
//
extern string rem4 = "=== Parámetros de equilibrio ===";
bool externo _IsStopLoss_0 = falso; // Habilitación del uso del nivel de equilibrio
externo int _StopLoss_0_From = 0; // Compensación desde el nivel de equilibrio (en puntos)
externo interno _StopLoss_0_Level = 15; // Nivel de equilibrio
//
cadena externa rem5 = "=== Parámetros de parada dinámica ===";
bool externo _IsTrailingStop = falso; // Habilitar parada final
bool _IsTrailingStopProfit = verdadero; // Habilitación de un trailing stop desde una posición de equilibrio
//externo int _TrailingStopProfit_From = 0; // Compensación desde el nivel de equilibrio (en puntos)
externo int _TrailingStopLevel = 15; // Nivel de parada final
externo int _TrailingStopStep = 5; // Paso de movimiento de parada final
//
cadena externa rem6 = "=== Configuración de herramientas ===";
cadena externa _Symboll = ""; // Nombre simbólico del instrumento: "" - símbolo actual
externo int _Timeframe = 0; // Período: 0 - período del gráfico actual
int_Digitss; // Número de dígitos después del punto decimal en el precio
doble _Puntos; // Tamaño en puntos en la moneda cotizada
externo int _Deslizamiento = 2; // deslizamiento
externo interno _Magic1 = 1281; // Número único de pedidos de EA (primer pedido)
externo interno _Magic2 = 1282; // Número único de pedidos de EA (segundo pedido)
//
cadena externa rem7 = "=== parámetros del indicador MA1 ===";
externo int _MA1_Timeframe = PERIODO_D1; // Período: 0 - período del gráfico actual
externo interno _MA1_Period = 20; // Período promedio para calcular el promedio móvil
externo interno _MA1_Shift = 0; // Desplazamiento del indicador en relación con el gráfico de precios
externo int _MA1_Method = 0; // Método de promedio: 0 - SMA, 1 - EMA, 2 - SMMA, 3 - LWMA
externo int _MA1_Applied_Price = 0; // Precio usado: 0 - cierre, 1 - apertura, 2 - alto, 3 - bajo
//
cadena externa rem8 = "=== parámetros del indicador MA2 ===";
externo int _MA2_Timeframe = PERIOD_H4; // Período: 0 - período del gráfico actual
externo interno _MA2_Period = 20; // Período promedio para calcular el promedio móvil
externo interno _MA2_Shift = 0; // Desplazamiento del indicador en relación con el gráfico de precios
externo int _MA2_Method = 0; // Método de promedio: 0 - SMA, 1 - EMA, 2 - SMMA, 3 - LWMA
externo int _MA2_Applied_Price = 0; // Precio usado: 0 - cierre, 1 - apertura, 2 - alto, 3 - bajo
//
extern string rem9 = "=== Parámetros del indicador de Bandas de Bollinger ===";
//externo int _BB_Timeframe = 0; // Período: 0 - período del gráfico actual
externo int _BB_Period = 20; // Período promedio de la línea del indicador principal
externo int _BB_Desviación = 2; // Desviación de la línea principal
externo interno _BB_Bands_Shift = 0; // Desplazamiento del indicador en relación con el gráfico de precios
externo int _BB_Applied_Price = 0; // Precio usado: 0 - cerrar
//
cadena externa rem10 = "=== Parámetros del indicador ZigZag ===";
//externo int _ZZ_Timeframe = 0; // Período: 0 - período del gráfico actual
externo interno _ZZ_ExtDepth = 12;
externo int _ZZ_ExtDeviation = 5;
externo int _ZZ_ExtBackstep = 3;
//
fecha y hora_hora anterior;
fechahora _HoraActual;
//
cadena_fstr;
int_tp;
//
void MaxOrders(int max_orders=5);
//=++============================================ ================++=
int inicial()
{
if(_Símbolo == "") _Símbolo = Símbolo();
//
_Digitss = MarketInfo(_Symbol, MODE_DIGITS);
_Puntos = MarketInfo(_Símbolo, MODO_PUNTO);
//
if(_Tiempo == 0) _Tiempo = Período();
Imprimir("v128-2 > init() >> _Marco de tiempo=", _Marco de tiempo,
"rem4=",_EsStopLoss_0,
"rem5=",_IsTrailingStop,_IsTrailingStopProfit);
//
_fstr = "v128_";
_tp = _FileReadWriteDouble(_fstr+"_tp.dat", 0); // asegúrese de que el archivo exista, si no existe, créelo
Imprimir("v128-2 > init() >> _Marco de tiempo=", _Marco de tiempo, " _tp=",_tp);
//
_TimePrevious=iTime(_Symbol, _Timeframe, 0);
//
Print("v128-2 > Hecho: init() >> _TimePrevious=", _TimePrevious, " ("", TimeToStr(_TimePrevious,TIME_DATE|TIME_MINUTES), ")");
retorno(0);
}
//=++============================================ ================++=
inicio int()
{
doble P_Cerrar1, P_Cerrar2;
doble BB_1_superior, BB_1_inferior;
doble MA1_0, MA2_0;
doble P_pedir, P_oferta;
bool is_signal_2_buy, is_signal_2_sell;
doble P1_comprar, P2_comprar, P3_comprar;
doble P1_venta, P2_venta, P3_venta;
bool is_b1 = falso, is_s1 = falso;
bool is_b2 = falso, is_s2 = falso;
boleto internacional;
//
_TimeCurrent = iTime(_Symbol, _Timeframe, 0);
if(_TiempoActual != _TiempoAnterior)
{
MA1_0 = iMA(_Symbol, _MA1_Timeframe, _MA1_Period, _MA1_Shift, _MA1_Method, _MA1_Applied_Price, 0);
MA2_0 = iMA(_Símbolo, _MA2_Marco de tiempo, _MA2_Período, _MA2_Shift, _MA2_Método, _MA2_Precio_aplicado, 0);
BB_1_upper = iBands(_Symbol, _Timeframe, _BB_Period,_BB_Deviation,_BB_Bands_Shift,_BB_Applied_Price, MODE_UPPER, 1);
BB_1_inferior = iBands(_Símbolo, _Marco de tiempo, _BB_Period,_BB_Desviación,_BB_Bands_Shift,_BB_Applied_Price, MODE_LOWER, 1);
P_Close1 = iClose(_Symbol, _Timeframe, 1);
P_Close2 = iClose(_Symbol, _Timeframe, 2);
P_ask = MarketInfo(_Symbol, MODE_ASK);
P_bid = MarketInfo(_Symbol, MODE_BID);
Imprimir("v120-4 > ", _Símbolo, " | ", _Período de tiempo,
" -> MA1_0=", MA1_0, " | MA2_0=", MA2_0,
" -> BB_1_superior=", BB_1_superior, " | BB_1_inferior=", BB_1_inferior,
" -> P_Cerrar1=", P_Cerrar1, " | P_Cerrar2=", P_Cerrar2,
" -> preguntar=", P_pedir, " | ofertar=", P_oferta);
//
is_signal_2_buy = P_bid >= MA1_0 && P_bid >= MA2_0 && P_Close1 >= BB_1_lower && P_Close2 <= BB_1_lower && P_bid >= BB_1_lower;
is_signal_2_sell = P_bid <= MA1_0 && P_bid <= MA2_0 && P_Close1 <= BB_1_upper && P_Close2 >= BB_1_upper && P_bid <= BB_1_upper;
Imprimir("v128-2 > ", _Símbolo, " | ", _Período de tiempo,
" -> is_signal2 -> comprar=", is_signal_2_buy, " | vender=", is_signal_2_sell);
// ========== por mercado
// ========== abriendo una orden de COMPRA
si (es_señal_2_comprar)
{
Imprimir("v128-2 > ", _Símbolo, " | ", _Período de tiempo,
" -> señal para abrir una orden de COMPRA");
PedidosDeleteAll(OP_SELL);
//
si(!es_b1 || !es_b2)
{
P1_comprar = P_pedir;
P3_buy = FindPriceMinMax(false) - (_SpaseFromMaxMin) * _Point;
_tp = (P1_compra - P3_compra) / _Punto * (_TakeProfit1_Proc / 100.0);
P2_comprar = DoubleTestZero(_tp, P1_comprar + (_tp) * _Punto);
//
_FileWriteDouble(_fstr+"_tp.dat", _tp);
//
Imprimir("v128-2 > ", _Símbolo, " | ", _Período de tiempo,
" -> COMPRAR -> P1_comprar=", P1_comprar, " | P2_comprar=", P2_comprar, " | P3_comprar=", P3_comprar, "_tp=", _tp);
//
ticket = OrderSend(_Symbol, OP_BUY, _Lots0_1, ND(P1_buy), _Slippage, ND(P3_buy), ND(P2_buy),
NULL, _Magic1, 0, CLR_NONE);
si (boleto == -1)
Imprimir("v128-2 > ", _Símbolo, " | ", _Período de tiempo,
" -> COMPRAR (1) > Error (apertura) #", GetLastError());
más es_b1 = verdadero;
//
ticket = OrderSend(_Symbol, OP_BUY, _Lots0_2, ND(P1_buy), _Slippage, ND(P3_buy), 0,
NULL, _Magic2, 0, CLR_NONE);
si (boleto == -1)
Imprimir("v128-2 > ", _Símbolo, " | ", _Período de tiempo,
" -> COMPRAR (2) > Error (apertura) #", GetLastError());
más es_b2 = verdadero;
//
}
más { es_b1 = verdadero; es_b2 = verdadero; }
}
más { es_b1 = verdadero; es_b2 = verdadero; }
//Imprimir("= comprar +++",is_b1,is_b2,"==",is_s1,is_s2);
// ========== abriendo una orden de VENTA
si (es_señal_2_venta)
{
Imprimir("v128-2 > ", _Símbolo, " | ", _Período de tiempo,
" -> señal para abrir una orden de VENTA");
PedidosDeleteAll(OP_BUY);
//
si(!es_s1 || !es_s2)
{
P1_venta = P_oferta;
P3_sell = FindPriceMinMax(true) + (_SpaseFromMaxMin) * _Point;
_tp = (P3_venta - P1_venta) / _Punto * (_TakeProfit1_Proc / 100.0);
P2_venta = DoubleTestZero(_tp, P1_sell - (_tp) * _Punto);
//
_FileWriteDouble(_fstr+"_tp.dat", _tp);
//
Imprimir("v128-2 > ", _Símbolo, " | ", _Período de tiempo,
" -> COMPRAR -> P1_venta=", P1_venta, " | P2_venta=", P2_venta, " | P3_venta=", P3_venta);
//
ticket = OrderSend(_Symbol, OP_SELL, _Lots0_1, ND(P1_sell), _Slippage, ND(P3_sell), ND(P2_sell),
NULL, _Magic1, 0, CLR_NONE);
si (boleto == -1)
Imprimir("v128-2 > ", _Símbolo, " | ", _Período de tiempo,
" -> VENDER (1) > Error (apertura) #", GetLastError());
más es_s1 = verdadero;
//
ticket = OrderSend(_Symbol, OP_SELL, _Lots0_2, ND(P1_sell), _Slippage, ND(P3_sell), 0,
NULL, _Magic2, 0, CLR_NONE);
si (boleto == -1)
Imprimir("v128-2 > ", _Símbolo, " | ", _Período de tiempo,
" -> VENDER (2) > Error (apertura) #", GetLastError());
más es_s2 = verdadero;
//
}
más { es_s1 = verdadero; es_s2 = verdadero; }
}
más { es_s1 = verdadero; es_s2 = verdadero; }
//Imprimir("= vender +++",is_b1,is_b2,"==",is_s1,is_s2);
// ==========
si(es_b1 && es_s1 && es_b2 && es_s2)
_TiempoAnterior=_TiempoActual;
}
//
if(_IsTrailingStop)
{
if( !FindOrders(_Magic1) ) TrailingStop(_tp);
}
//
si (_EsStopLoss_0)
StopLoss_0(_StopLoss_0_From);
//
retorno(0);
}
//=++============================================ ================++=
double DoubleTestZero(doble valor, doble nuevo_valor)
{
if(valor==0) return(valor);
else return(nuevo_valor);
}
//=++============================================ ================++=
doble ND (doble valor)
{
retorno (NormalizeDouble (valor, _Digits));
}
//=++============================================ ================++=
// cierre de órdenes. Terminar al cerrar todo
void OrdersDeleteAll(int cmd)
{
while(ContarPedidos(cmd) > 0)
{
for(int i = OrdersTotal() - 1; i >= 0 ; i--)
{
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
if( (SímboloPedido() == _Símbolo)
&& (NúmeroMágicoPedido() == _Magia1 || NúmeroMágicoPedido() == _Magia2)
&& (TipoPedido() == cmd) )
{
if(OrderType() == OP_BUY)
if(!OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_BID), _Slippage, CLR_NONE))
Imprimir("v128-2 > ", _Símbolo, " > COMPRAR -> ticket=", OrderTicket(),
" -> Error (cierre) #", GetLastError());
if(TipoPedido() == OP_SELL)
if(!OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_ASK), _Slippage, CLR_NONE))
Imprimir("v128-2 > ", _Símbolo, " > VENDER -> ticket=", OrderTicket(),
" -> Error (cierre) #", GetLastError());
}
}
}
}
// numero de pedidos
}
//=++============================================ ================++=
// contando el número de pedidos en la dirección
int CuentaPedidos(int cmd)
{
entero n = 0;
for(int i = OrdersTotal() - 1; i >= 0 ; i--)
{
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
if( (SímboloPedido() == _Símbolo)
&& (NúmeroMágicoPedido() == _Magia1 || NúmeroMágicoPedido() == _Magia2)
&& (TipoPedido() == cmd) ) n++;
}
}
retorno(n);
}
//=++============================================ ================++=
// busca una orden por arte de magia
bool BuscarPedidos(int magic)
{
for(int i = OrdersTotal() - 1; i >= 0 ; i--)
{
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
if( (OrderSymbol() == _Symbol) && (OrderMagicNumber() == magic) )
retorno (verdadero);
}
}
falso retorno);
}
//=++============================================ ================++=
// calcular el nivel de equilibrio por arte de magia
anular StopLoss_0 (int desde)
{
doble punto de beneficio, oferta, demanda;
bool es;
doble P3_compra, P3_venta;
//
for(int i = OrdersTotal() - 1; i >= 0 ; i--)
{
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
if(!( (OrderSymbol() == _Symbol) && (OrderMagicNumber() == _Magic1 || OrderMagicNumber() == _Magic2) )) continuar;
//
if(OrderType() == OP_BUY)
{
oferta = MarketInfo(_Symbol, MODE_BID);
punto de beneficio = (oferta - OrderOpenPrice()) / _Point;
es = punto de beneficio >= _StopLoss_0_Level + from;
P3_buy = ND( OrderOpenPrice() + from * _Point );
//
if( es && ( OrderStopLoss() == 0 || OrderStopLoss() < P3_buy ) )
{
Imprimir("v128-2 b4 >", _Símbolo, " | ", _Período de tiempo,
" -> Oferta=", MarketInfo(_Symbol, MODE_BID),
" | p/o=", OrderOpenPrice(), " | s/l=", OrderStopLoss(), " | P3_buy=", P3_buy,
" | d=", _StopLoss_0_Level, " | punto de beneficio=", punto de beneficio);
if(!OrderModify(OrderTicket(), OrderOpenPrice(), P3_buy, OrderTakeProfit(), 0, CLR_NONE))
Imprimir("v128-2 b4 > ", _Símbolo, " | ", _Período de tiempo,
" -> COMPRAR > ticket=", OrderTicket(), " > Error (punto de equilibrio) #", GetLastError());
}
}
//
si no (OrderType() == OP_SELL)
{
preguntar = MarketInfo(_Symbol, MODE_ASK);
punto de beneficio = (OrderOpenPrice() - ask) / _Point;
es = punto de beneficio >= _StopLoss_0_Level + from;
P3_sell = ND( OrderOpenPrice() - from * _Point );
//
if( es && ( OrderStopLoss() == 0 || OrderStopLoss() > P3_sell ) )
{
Imprimir("v128-2 b4 >", _Símbolo, " | ", _Período de tiempo,
" -> Preguntar =", MarketInfo(_Symbol, MODE_ASK),
" | p/o=", OrderOpenPrice(), " | s/l=", OrderStopLoss(), " | P3_sell=", P3_sell,
" | d=", _StopLoss_0_Level, " | punto de beneficio=", punto de beneficio);
if(!OrderModify(OrderTicket(), OrderOpenPrice(), P3_sell, OrderTakeProfit(), 0, CLR_NONE))
Imprimir("v128-2 b4 > ", _Símbolo, " | ", _Período de tiempo,
" -> VENDER -> ticket=", OrderTicket(), " > Error (punto de equilibrio) #", GetLastError());
}
}
}
}
}
//=++============================================ ================++=
// calculando el trailing stop por arte de magia
anular TrailingStop (int de)
{
doble punto de beneficio, oferta, demanda;
doble del precio;
//
for(int i = OrdersTotal() - 1; i >= 0 ; i--)
{
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
if(!( (OrderSymbol() == _Symbol) && (OrderMagicNumber() == _Magic1 || OrderMagicNumber() == _Magic2) )) continuar;
//
if(OrderType() == OP_BUY)
{
if(_IsTrailingStopProfit) fromprice = OrderOpenPrice() + from * _Point;
else fromprice = OrderStopLoss();
//
oferta = MarketInfo(_Symbol, MODE_BID);
punto de beneficio = (oferta - ND(desdeprecio)) / _Punto;
//
if( punto de beneficio >= _TrailingStopLevel &&
oferta > (OrderStopLoss() + (_TrailingStopLevel + _TrailingStopStep) * _Point) )
{
Imprimir("v128-2 v4 >", _Símbolo, " | ", _Período de tiempo,
" -> Oferta=", MarketInfo(_Symbol, MODE_BID),
" | p/o=", OrderOpenPrice(), " | s/l=", OrderStopLoss(),
" | d=", _TrailingStopLevel, " | punto de beneficio=", punto de beneficio);
if(!OrderModify(OrderTicket(), OrderOpenPrice(), ND(bid - (_TrailingStopLevel) * _Point),
OrdenTakeProfit(), 0, CLR_NONE))
{
Imprimir("v128-2 v4 >", _Símbolo, " | ", _Período de tiempo,
" -> COMPRAR > ticket=", OrderTicket(), " > Error (trailing stop) #", GetLastError());
}
}
}
//
si no (OrderType() == OP_SELL)
{
if(_IsTrailingStopProfit) fromprice = OrderOpenPrice() - from * _Point;
else fromprice = OrderStopLoss();
//
preguntar = MarketInfo(_Symbol, MODE_ASK);
punto de beneficio = (ND(desdeprecio) - preguntar) / _Punto;
//
if( punto de beneficio >= _TrailingStopLevel &&
preguntar < (OrderStopLoss() - (_TrailingStopLevel + _TrailingStopStep) * _Point) )
{
Imprimir("v128-2 v4 >", _Símbolo, " | ", _Período de tiempo,
" -> Preguntar=", MarketInfo(_Símbolo, MODE_ASK),
" | p/o=", OrderOpenPrice(), " | s/l=", OrderStopLoss(),
" | d=", _TrailingStopLevel, " | punto de beneficio=", punto de beneficio);
if(!OrderModify(OrderTicket(), OrderOpenPrice(), ND(preguntar + (_TrailingStopLevel) * _Point),
OrdenTakeProfit(), 0, CLR_NONE))
{
Imprimir("v128-2 v4 >", _Símbolo, " | ", _Período de tiempo,
" -> VENDER > ticket=", OrderTicket(), " > Error (trailing stop) #", GetLastError());
}
}
}
}
}
}
//=++============================================ ================++=
// Encontrar el fondo local. Devuelve el precio
double FindPriceMinMax(bool isUp)
{
desplazamiento int = 1;
doble precio = 0, p0,p1,p2;
mientras (precio == 0)
{
p0 = iCustom(_Symbol, _Timeframe, "ZigZag", _ZZ_ExtDepth, _ZZ_ExtDeviation, _ZZ_ExtBackstep, 0, shift);
p1 = iCustom(_Symbol, _Timeframe, "ZigZag", _ZZ_ExtDepth, _ZZ_ExtDeviation, _ZZ_ExtBackstep, 1, shift);
p2 = iCustom(_Symbol, _Timeframe, "ZigZag", _ZZ_ExtDepth, _ZZ_ExtDeviation, _ZZ_ExtBackstep, 2, shift);
//Imprimir("v128-2 >", _Símbolo, " | ", _Período de tiempo,
// " > sift=", shift, " | p0=", p0, " | p1=", p1, " | p2=", p2);
si (está arriba)
{
if(p0 !=0 && p0 == p1) // vértice encontrado
precio = p0;
}
demás
{
if(p0 != 0 && p0 == p2) // fondo encontrado
precio = p0;
}
turno++;
}
//Imprimir("v128-2 >", _Símbolo, " | ", _Período de tiempo,
// " -> retorno(precio)=", precio);
devolución (precio);
}
//============================================== = ====================
// Lee la variable del archivo.
// Si el archivo no existe, crea un archivo y escribe la variable en el archivo
double _FileReadWriteDouble(nombre de archivo de cadena, valor doble)
{
int h1 = FileOpen(nombre de archivo, FILE_BIN);
si (h1 > 0)
{
valor = FileReadDouble(h1, DOUBLE_VALUE);
ArchivoCerrar(h1);
}
demás
{
h1 = FileOpen(nombre de archivo, FILE_BIN|FILE_WRITE);
FileWriteDouble(h1, valor, DOBLE_VALOR);
ArchivoCerrar(h1);
}
retorno(valor);
}
//============================================== = ====================
// Escribir variable en archivo
void _FileWriteDouble(nombre de archivo de cadena, valor doble)
{
int h1 = FileOpen(nombre de archivo, FILE_BIN|FILE_WRITE);
FileWriteDouble(h1, valor, DOBLE_VALOR);
ArchivoCerrar(h1);
}