lunes, 21 de diciembre de 2009

Felicitaciones Navideñas.

Ante todo felicitar a todos los seguidores del blog, pues entramos en una época de felicitaciones y alegría para todo el mundo.

!FELICES FIESTAS A TODOS!

Después pediros perdón por las tardanzas, pues estuve bastante liado con otros proyectos, !Con muchas cosas pero poco tiempo, pues esto no me da para vivir!. Pero como lo hago por afición, pues seguimos ahí hasta que el cuerpo y la mente aguante...
Bueno, basta de paranoias... Y vamos al grano.
No se si alguna vez os a pasado que vuestro sistema que estáis probando abre demasiadas órdenes y os cuesta controlar cuantas órdenes de compra y cuantas órdenes de venta tenéis abiertas.
El siguiente expert os crea una tabla en el lado izquierdo de vuestra gráfica alertándonos de cuantas órdenes de compra y cuantas órdenes de venta tenemos abiertas, además también nos enseña cuanto ganamos ó perdemos con dichas órdenes.
Os dejo una imagen para aclarar un poco lo mencionado:


Y aquí os dejo el enlace al código fuente:
Que hace el código, pues el código tiene dos funciones: num_ordabiertas() y tabla_ordenes(int total, int compras, int ventas,
int dif, double gancompras, double ganventas, double difgan,
int desy).

La primera función se encarga de calcular el número de operaciones que tenemos abiertas.
La segunda función se encarga de visualizar los cálculos anteriores en la pantalla gráfica en la que incluyamos el expert.

Saludos a todos, espero que os sirva en vuestro trading. Gracias por vuestro tiempo y que paseis buenas fiestas.

martes, 22 de septiembre de 2009

Expert advisor cesarz_v01

Bien, según he entendido en uno de los mensajes se me pedía un asesor experto que introdujese tres órdenes del tipo:

  • Una operacion de venta a las 12pm hora EST y cierre con ganacias de 2pip con stop lose de 50pip para el EUR/USD
  • Que abra una operacion de compra a las 2pm hora EST con los mismo parametros, 2pip de ganacias 50 de stop los con EUR/USD
  • Y finalmente que active otra operacion a las 7pm EST de compra con lo mismo.
Bien, como la programación es un mundo en el cual las cosas se pueden hacer de muchas maneras y no hay una única forma de solucionar un problema, yo he optado por los siguiente, aunque quizás no sea la mejor forma.

He optado por poner tres variables externas por cada una de las órdenes que se van ha ejecutar, de manera que podamos introducir la hora en formato (0 - 23), el stop loss y el take profit para cada una de las tres órdenes independientemente. Esto se modificará cuando se coloca el expert advisor en la gráfica correspondiente de manera que en la pestaña entradas tendremos:

  • Para la primera orden tendremos: hora1, sl1, tp1.
  • Para la segunda orden tendremos: hora2, sl2, tp2.
  • Para la tercera orden tendremos: hora3, sl3, tp3.
Por ejemplo: si ponemos en hora1 el valor de 12, tan solo se nos ejecutará una orden a partir de las 12 (hora local, que es la que te aparece en el metatrader).

Bueno, creo que es bastante sencillo, probarlo y jugar con él. Os dejo el código para que lo modifiqueis a vuestro antojo.

Ojo el expert advisor no ha sido probado en cuenta real, así que si lo probais en cuenta real es bajo vuestra responsabilidad.

Saludos, y buen trading

jueves, 17 de septiembre de 2009

Crear un archivo CSV con metatrader.

Bien, voy a explicar aquí como realizar un archivo CSV con metatrader, pero antes deberíamos saber que es un archivo CSV, para ello buscamos un poco de información en google, en mi caso la wikipedia:

Archivos csv.

Pues lo siguiente es realizar una función que nos que nos introduzca una línea en formato csv a un archivo.

int crearcsv(string cadena)
{
int handle = FileOpen("prueba.csv", FILE_CSV|FILE_WRITE, ' ');
string str;
if(handle < 1)
{
Print("Error:", GetLastError());
return(handle);
}
else
{
if(size==0)
{
str = cadena;
FileWrite(handle, PrepareString(str));
}
}
FileClose(handle);
return(0);
}


La función anterior crea un archivo con el nombre prueba he introduce en el la cadena que se le ha pasado a la función. Ojo si el archivo ya existía se borrará toda la información que contenía y creará un nuevo archivo con la cadena.

Claro está que si deseas abrir con otro programa este tipo de archivos, en la cadena deberás introducir el formato adecuado.

Por ejemplo, desde otro lugar del programa llamamos a la función de la siguiente manera:

string linea="orden; Margen; precio;";
crearcsv(linea);

Si abres el archivo con un editor de textos deberías observar una línea con:
orden; Margen; precio;

Bueno, con esto y un poco de imaginación se pueden hacer muchas cosas.

Solo falta decir que los archivos creados con el metatrader por defecto se hacen en el directorio: \experts\files\

Saludos, buen trading.

martes, 15 de septiembre de 2009

Nueva version de pabpozzi.

Bien os adjunto los nuevos archivos para el indicador, espero que os sirva, he corregido algunos errores que tenia la versión anterior, además el nuevo indicador almacena los datos en un archivo.

Cuando adjuntas el asesor experto, en la ventana de entradas teneis una variable que se llama estrategia, esta variable se usa para dar un nombre al archivo de la estrategia. Este archivo se creará en la carpeta experts/files/nombredelaestrategia.csv , con este archivo se pueden exportar datos a una hoja de excel, yo uso openoffice no se si funcionará con microsoft.

Por último, os comento donde debéis colocar los archivos:


Espero que os sea de utilidad.

Saludos, que tengais un buen trading.

viernes, 11 de septiembre de 2009

Indicador mejorado.

Bien, ayer hice un indicador a todo correr, mal asunto ese.

Pues dejo aquí una mejora del mismo, además le voy a poner un nombre en honor al que me dío la idea, así que si no le importa Sr. le llamaré pabpozzi.

No cuelgo el código porque se hace muy tedioso, así que tan solo dejo una imagen del indicador, así como los enlaces correspondientes a la versión pabpozzi.



Enlaces de descarga:


Saludos a todos.

jueves, 10 de septiembre de 2009

El margen libre.

Contestando al comentario del señor Anonimo, manuales del metatrader no dispongo de ellos, me apoyo en las explicaciones de las funciones que trae el programa, en la subcarpeta de Dictionary, por supuesto estan en ingles.

Si te vale unos manuales rudimentarios pincha en el siguiente enlace e iras a un blog que tiene dos manuales básicos traducidos al español.

Programado en Forex.

A tu otra cuestion, mira la función:

double AccountFreeMargin( )

No se si te vale para lo que tú deseas.

Te dejo el código para que lo compiles del siguiente indicador, si modificas la variable esquina puedes dibujarlo en la esquina superior, inferior, derecha o izquierda. Al final dejo un enlace desde donde te puedes bajar el indicador.

//+------------------------------------------------------------------+
//| Margen libre.mq4 |
//| Copyright © 2009, MetaQuotes Software Corp. |
//| http://www.metaquotes.net |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2009, MetaQuotes Software Corp."
#property link "http://www.metaquotes.net"

#property indicator_chart_window
//+------------------------------------------------------------------+
//| Custom indicator initialization function |
//+------------------------------------------------------------------+
extern int esquina=2;
double margenlibre;
double maximaganancia;
double maximaperdida;
double inicio;

int init()
{
//---- indicators
margenlibre=AccountFreeMargin();
inicio=margenlibre;
maximaganancia=0;
maximaperdida=0;

//----
return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function |
//+------------------------------------------------------------------+
int deinit()
{
//----

//----
return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator iteration function |
//+------------------------------------------------------------------+
int start()
{
int counted_bars=IndicatorCounted();
//----

//if(Fun_NuevaBarra())
// {
if(AccountFreeMargin() >= margenlibre)
maximaganancia=MathAbs(AccountFreeMargin()-margenlibre);
if(AccountFreeMargin() <= margenlibre) maximaperdida=MathAbs(AccountFreeMargin()-margenlibre); // } ObjectDelete("LabelMargen"); ObjectCreate("LabelMargen", OBJ_LABEL, 0,0,0,0,0); ObjectSet("LabelMargen", OBJPROP_CORNER, esquina); ObjectSet("LabelMargen", OBJPROP_XDISTANCE, 70); ObjectSet("LabelMargen", OBJPROP_YDISTANCE, 10); ObjectSet("LabelMargen",OBJPROP_COLOR,Red); ObjectSetText("LabelMargen","Margen libre",10,"Arial",Red); ObjectDelete("Margenlibre"); ObjectCreate("Margenlibre", OBJ_LABEL, 0,0,0,0,0); ObjectSet("Margenlibre", OBJPROP_CORNER, esquina); ObjectSet("Margenlibre", OBJPROP_XDISTANCE, 170); ObjectSet("Margenlibre", OBJPROP_YDISTANCE, 10); ObjectSet("Margenlibre",OBJPROP_COLOR,Red); ObjectSetText("Margenlibre",DoubleToStr(AccountFreeMargin(),4),10,"Arial",Red); ObjectDelete("LabelMaximaganancia"); ObjectCreate("LabelMaximaganancia", OBJ_LABEL, 0,0,0,0,0); ObjectSet("LabelMaximaganancia", OBJPROP_CORNER, esquina); ObjectSet("LabelMaximaganancia", OBJPROP_XDISTANCE, 70); ObjectSet("LabelMaximaganancia", OBJPROP_YDISTANCE, 30); ObjectSet("LabelMaximaganancia",OBJPROP_COLOR,Red); ObjectSetText("LabelMaximaganancia","Max. ganancia",10,"Arial",Green); ObjectDelete("Maximaganancia"); ObjectCreate("Maximaganancia", OBJ_LABEL, 0,0,0,0,0); ObjectSet("Maximaganancia", OBJPROP_CORNER, esquina); ObjectSet("Maximaganancia", OBJPROP_XDISTANCE, 170); ObjectSet("Maximaganancia", OBJPROP_YDISTANCE, 30); ObjectSet("Maximaganancia",OBJPROP_COLOR,Green); ObjectSetText("Maximaganancia",DoubleToStr(maximaganancia,2) ,10,"Arial",Green); ObjectDelete("LabelMaximaperdida"); ObjectCreate("LabelMaximaperdida", OBJ_LABEL, 0,0,0,0,0); ObjectSet("LabelMaximaperdida", OBJPROP_CORNER, esquina); ObjectSet("LabelMaximaperdida", OBJPROP_XDISTANCE, 70); ObjectSet("LabelMaximaperdida", OBJPROP_YDISTANCE, 50); ObjectSet("LabelMaximaperdida",OBJPROP_COLOR,Red); ObjectSetText("LabelMaximaperdida","Max. perdida",10,"Arial",Red); ObjectDelete("Maximaperdida"); ObjectCreate("Maximaperdida", OBJ_LABEL, 0,0,0,0,0); ObjectSet("Maximaperdida", OBJPROP_CORNER, esquina); ObjectSet("Maximaperdida", OBJPROP_XDISTANCE, 170); ObjectSet("Maximaperdida", OBJPROP_YDISTANCE, 50); ObjectSet("Maximaperdida",OBJPROP_COLOR,Red); ObjectSetText("Maximaperdida",DoubleToStr(maximaperdida,4),10,"Arial",Red); ObjectDelete("Labelinicio"); ObjectCreate("Labelinicio", OBJ_LABEL, 0,0,0,0,0); ObjectSet("Labelinicio", OBJPROP_CORNER, esquina); ObjectSet("Labelinicio", OBJPROP_XDISTANCE, 70); ObjectSet("Labelinicio", OBJPROP_YDISTANCE, 70); ObjectSet("Labelinicio",OBJPROP_COLOR,Red); ObjectSetText("Labelinicio","Inicio",10,"Arial",White); ObjectDelete("Inicio"); ObjectCreate("Inicio", OBJ_LABEL, 0,0,0,0,0); ObjectSet("Inicio", OBJPROP_CORNER, esquina); ObjectSet("Inicio", OBJPROP_XDISTANCE, 170); ObjectSet("Inicio", OBJPROP_YDISTANCE, 70); ObjectSet("Inicio",OBJPROP_COLOR,Red); ObjectSetText("Inicio",DoubleToStr(inicio,2),10,"Arial",Red); //---- return(0); } //+++++++ //Funcion para calcular una nueva vela bool Fun_NuevaBarra() { bool BarraNueva; static datetime NuevaHora=0; // Deteccion nueva hora BarraNueva=false; // 0 - misma vela ; 1- vela nueva if(NuevaHora!=Time[0]) // Si el hora es cero comienza vela { NuevaHora=Time[0]; BarraNueva=true; //Alert("Barra nueva"); //Avisa de una barra nueva } return(BarraNueva) ;
}
//+------------------------------------------------------------------+


Descargar el indicador: Saludos a todos.

Nota: Es un indicador y como tal se deberá colocar en la carpeta indicators.

martes, 11 de agosto de 2009

Expert advisor para indicar los patrones de velas (2).

Dejo aquí los archivos con todo el código que estoy usando para hacer un seguidor de los patrones de velas.

Ojo, aún no se encuentran todos los patrones de velas, además yo no me fiaría de ellos pues la mayoría aún no se han producido, y los que se han producido no son fiables o los tengo que reprogramar. Si lo usas y crees que tengo que modificar algo ponte en contacto conmigo, pero si lo usas para realizar entradas al mercado yo no me responsabilizo del expert.

Os dejo un enlace para que os descargueis los tres archivos y los podáis compilar en vuestro sistema.

oscar01
Grafios
Patronvelas

Saludos a todos.

miércoles, 22 de julio de 2009

La funcion tipo de vela II.

Bueno, despues de revisar las velas he añadido alguna más a la función como cada vez se hace mas larga la función dejo un enlace ha dicha función.

En el archivo también se pueden encontrar otras funciones, las cuales calculan la tendencia previa, así como los patrones. De momento no las explico, por el hecho de que aún estoy retocándolas, y estas funciones formarán parte de un indicador general.

Además, aún me queda por comprobar el buen funcionamiento.

La función de las velas es:
int tipovela(int i)
{
//Dojis
if(Open[i] == Close[i])
{
if(Low[i] == Open[i])
{
Alert("Doji lapida");
return(4);
}
if((High[i]-Open[i]) == (Open[i]-Low[i]))
{
Alert("Doji clasico");
return(1);
}
if((High[i]-Open[i]) > (3*(Open[i]-Low[i])))
{
Alert("Doji larga sombra superior");
return(2);
}
if((Open[i]-Low[i]) > (3*(High[i]-Open[i])))
{
Alert("Doji larga sombra inferior");//Doji libelula
return(3);
}
Alert("Doji");
return(27);
}


//Marubozus
//Marubozu alcista
if((High[i] == Close[i]) && (Close[i] > Open[i]) &&
(Open[i] == Low[i]))
{
Alert("Marubozu alcista");
return(5);
}
//Marubozu bajista
if((High[i] == Open[i]) && (Open[i] > Close[i]) &&
(Close[i] == Low[i]))
{
Alert("Marubozu bajista");
return(6);
}
//Marubozu cerrado alcista
if((High[i] == Close[i]) && (Close[i] > Open[i]) &&
(Open[i] > Low[i]) &&
((Close[i]-Open[i]) > (3*(Open[i]-Low[i]))) )
{
Alert("Marubozu cerrado alcista");
return(10);
}
//Marubozu cerrado bajista
if((High[i] > Open[i]) && (Open[i] > Close[i]) &&
(Close[i] == Low[i]) &&
((Open[i]-Close[i]) > (3*(High[i]-Open[i]))))
{
Alert("Marubozu cerrado bajista");
return(13);
}
//Marubozu abierto alcista
if((High[i] > Close[i]) && (Close[i] > Open[i]) &&
(Open[i] == Low[i]) &&
((Close[i]-Open[i]) > (3*(High[i]-Close[i]))))
{
Alert("Marubozu abierto alcista");
return(16);
}
//Marubozu abierto bajista
if((High[i] == Open[i]) && (Open[i] > Close[i]) &&
(Close[i] > Low[i]) &&
((Open[i]-Close[i]) > (3*(Close[i]-Low[i]))))
{
Alert("Marubozu abierto bajista");
return(17);
}
//Martillo invertido alcista
if((High[i] > Close[i]) && (Close[i] > Open[i]) &&
(Open[i] == Low[i]) &&
((High[i]-Close[i]) > (2*(Close[i]-Open[i]))))
{
Alert("Martillo invertido alcista");
return(14);
}
//Martillo invertido bajista
if((High[i] > Open[i]) && (Open[i] > Close[i]) &&
(Close[i] == Low[i]) &&
((High[i]-Open[i]) > (2*(Open[i]-Close[i]))))
{
Alert("Martillo invertido bajista");
return(15);
}
//Martillo alcista
if((High[i] == Close[i]) && (Close[i] > Open[i]) &&
(Open[i] > Low[i]) &&
((Open[i]-Low[i]) > (2*(Close[i]-Open[i]))))
{
Alert("Martillo alcista");
return(12);
}
//Martillo bajista
if((High[i] == Open[i]) && (Open[i] > Close[i]) &&
(Close[i] > Low[i]) &&
((Close[i]-Low[i]) > (2*(Open[i]-Close[i]))))
{
Alert("Martillo bajista");
return(11);
}
//Larga sombra superior alcista
if((High[i] > Close[i]) && (Close[i] > Open[i]) &&
(Open[i] > Low[i]) &&
((High[i]-Close[i]) > (3*(Open[i]-Low[i]))) &&
((High[i]-Close[i]) > (3*(Close[i]-Open[i]))))
{
Alert("Larga sombra superior alcista");
return(19);
}
//Larga sombra superior bajista
if((High[i] > Open[i]) && (Open[i] > Close[i]) &&
(Close[i] > Low[i]) &&
((High[i]-Open[i]) > (3*(Close[i]-Low[i]))) &&
((High[i]-Open[i]) > (3*(Open[i]-Close[i]))))
{
Alert("Larga sombra superior bajista");
return(20);
}
//Larga sombra inferior alcista
if((High[i] > Close[i]) && (Close[i] > Open[i]) &&
(Open[i] > Low[i]) &&
((Open[i]-Low[i]) > (3*(Close[i]-Open[i]))) &&
((Open[i]-Low[i]) > (3*(High[i]-Close[i]))))
{
Alert("Larga sombra inferior alcista");
return(21);
}
//Larga sombra inferior bajista
if((High[i] > Open[i]) && (Open[i] > Close[i]) &&
(Close[i] > Low[i]) &&
((Close[i]-Low[i]) > (3*(Open[i]-Close[i]))) &&
((Close[i]-Low[i]) > (3*(High[i]-Open[i]))))
{
Alert("Larga sombra inferior bajista");
return(22);
}
//Onda alta alcista
if((High[i] > Close[i]) && (Close[i] > Open[i]) &&
(Open[i] > Low[i]) &&
((High[i]-Close[i]) > (3*(Close[i]-Open[i]))) &&
((Open[i]-Low[i]) > (3*(Close[i]-Open[i]))))
{
Alert("Onda alta alcista");
return(23);
}
//Onda alta bajista
if((High[i] > Open[i]) && (Open[i] > Close[i]) &&
(Close[i] > Low[i]) &&
((High[i]-Open[i]) > (3*(Open[i]-Close[i]))) &&
((Close[i]-Low[i]) > (3*(Open[i]-Close[i]))) )
{
Alert("Onda alta bajista");
return(24);
}
//Peonza alcista
if((High[i] > Close[i]) && (Close[i] > Open[i]) &&
(Open[i] > Low[i]) &&
// ((High[i]-Close[i]) < (Close[i]-Open[i])) && // ((Open[i]-Low[i]) < (Close[i]-Open[i])) && ((High[i]-Close[i]) == (Close[i]-Open[i])) && ((Open[i]-Low[i]) == (Close[i]-Open[i])) && ((MathAbs(Close[i]-Open[i])) < (MathAbs(Close[i+1]-Open[i+1]))) && ((MathAbs(Close[i]-Open[i])) < (MathAbs(Close[i+2]-Open[i+2]))) && ((MathAbs(Close[i]-Open[i])) < (MathAbs(Close[i+3]-Open[i+3]))) ) { Alert("Peonza alcista"); return(8); } //Peonza bajista if((High[i] > Open[i]) && (Open[i] > Close[i]) &&
(Close[i] > Low[i]) &&
((High[i]-Open[i]) < (Open[i]-Close[i])) && ((Close[i]-Low[i]) < (Open[i]-Close[i])) && ((High[i]-Open[i]) == (Close[i]-Low[i])) && ((MathAbs(Close[i]-Open[i])) < (MathAbs(Close[i+1]-Open[i+1]))) && ((MathAbs(Close[i]-Open[i])) < (MathAbs(Close[i+2]-Open[i+2]))) && ((MathAbs(Close[i]-Open[i])) < (MathAbs(Close[i+3]-Open[i+3]))) ) { Alert("Peonza bajista"); return(7); } //Gran vela alcista if((High[i] > Close[i]) && (Close[i] > Open[i]) &&
(Open[i] > Low[i]) &&
((Close[i]-Open[i]) > (3*(High[i]-Close[i]))) &&
((Close[i]-Open[i]) > (3*(Open[i]-Low[i]))) &&
((MathAbs(Close[i]-Open[i])) > (3*(MathAbs(Open[i+1]-Close[i+1])))) &&
((MathAbs(Close[i]-Open[i])) > (3*(MathAbs(Open[i+2]-Close[i+2])))) &&
((MathAbs(Close[i]-Open[i])) > (3*(MathAbs(Open[i+3]-Close[i+3])))) )
{
Alert("Gran vela alcista");
return(9);
}
//Larga vela alcista
if((High[i] > Close[i]) && (Close[i] > Open[i]) &&
(Open[i] > Low[i]) &&
((MathAbs(Close[i]-Open[i])) > (MathAbs(Close[i+1]-Open[i+1]))) &&
((MathAbs(Close[i]-Open[i])) > (MathAbs(Close[i+2]-Open[i+2]))) )
{
Alert("Larga vela alcista");
return(25);
}

//Gran vela bajista
if((High[i] > Open[i]) && (Open[i] > Close[i]) &&
(Close[i] > Low[i]) &&
((Open[i]-Close[i]) > (3*(High[i]-Open[i]))) &&
((Open[i]-Close[i]) > (3*(Close[i]-Low[i]))) &&
((MathAbs(Close[i]-Open[i])) > (3*(MathAbs(Open[i+1]-Close[i+1])))) &&
((MathAbs(Close[i]-Open[i])) > (3*(MathAbs(Open[i+2]-Close[i+2])))) &&
((MathAbs(Close[i]-Open[i])) > (3*(MathAbs(Open[i+3]-Close[i+3])))) )
{
Alert("Gran vela bajista");
return(18);
}
//Larga vela bajista
if((High[i] > Open[i]) && (Open[i] > Close[i]) &&
(Close[i] > Low[i]) &&
((MathAbs(Close[i]-Open[i])) > (MathAbs(Close[i+1]-Open[i+1]))) &&
((MathAbs(Close[i]-Open[i])) > (MathAbs(Close[i+2]-Open[i+2]))) )
{
Alert("Larga vela bajista");
return(26);
}
//Ultima comprobacion
//Vela bajista
if((High[i] >= Open[i]) && (Open[i] > Close[i]) &&
(Close[i] >= Low[i]))
{
Alert("Vela bajista");
return(28);
}
//Vela alcista
if((High[i] >= Close[i]) && (Close[i] > Open[i]) &&
(Open[i] >= Low[i]))
{
Alert("Vela alcista");
return(29);
}
return(0);

}
Saludos a todos y espero que os valga.

jueves, 9 de julio de 2009

La función tipo de vela.

Bien supongo que todos conoceis el libro de "Manual de candlestick", Velas japonesas, del señor Ustin.

En el libro se presentan diversos patrones de velas japonesas, supongo que habrá indicadores para metatrader que presenten los patrones de las velas japonesas, pero como a mi me gusta programar decidí hacer una función a la cual se le pasara el número de vela y me dijera el tipo de vela que es.

He tardado en publicar esta función por haber tenido problemas, ya que cuando tenía todo el código programado, se me borró del ordenador, cosas extrañas que pasan, por eso te recomiendo que realices copias de seguridad cada cierto tiempo.

Espero que os guste la función siguiente.

La función solo nos dice el tipo de vela que se ha formado, no identifica los patrones, eso lo haré mas adelante.

int tipovela(int i)
{
//Dojis
if(Open[i] == Close[i])
{
if(Low[i] == Open[i])
{
Alert("Doji lapida");
return(4);
}
if((High[i]-Open[i]) == (Open[i]-Low[i]))
{
Alert("Doji clasico");
return(1);
}
if((High[i]-Open[i]) > (3*(Open[i]-Low[i])))
{
Alert("Doji larga sombra superior");
return(2);
}
if((Open[i]-Low[i]) > (3*(High[i]-Open[i])))
{
Alert("Doji larga sombra inferior");//Doji libelula
return(3);
}
}

//Marubozus
//Marubozu alcista
if((High[i] == Close[i]) && (Close[i] > Open[i]) &&
(Open[i] == Low[i]))
{
Alert("Marubozu alcista");
return(5);
}
//Marubozu bajista
if((High[i] == Open[i]) && (Open[i] > Close[i]) &&
(Close[i] == Low[i]))
{
Alert("Marubozu bajista");
return(6);
}
//Marubozu cerrado alcista
if((High[i] == Close[i]) && (Close[i] > Open[i]) &&
(Open[i] > Low[i]) &&
((Close[i]-Open[i]) > (3*(Open[i]-Low[i]))) )
{
Alert("Marubozu cerrado alcista");
return(10);
}
//Marubozu cerrado bajista
if((High[i] > Open[i]) && (Open[i] > Close[i]) &&
(Close[i] == Low[i]) &&
((Open[i]-Close[i]) > (3*(High[i]-Open[i]))))
{
Alert("Marubozu cerrado bajista");
return(13);
}
//Marubozu abierto alcista
if((High[i] > Close[i]) && (Close[i] > Open[i]) &&
(Open[i] == Low[i]) &&
((Close[i]-Open[i]) > (3*(High[i]-Close[i]))))
{
Alert("Marubozu abierto alcista");
return(16);
}
//Marubozu abierto bajista
if((High[i] == Open[i]) && (Open[i] > Close[i]) &&
(Close[i] > Low[i]) &&
((Open[i]-Close[i]) > (3*(Close[i]-Low[i]))))
{
Alert("Marubozu abierto bajista");
return(17);
}
//Martillo invertido alcista
if((High[i] > Close[i]) && (Close[i] > Open[i]) &&
(Open[i] == Low[i]) &&
((High[i]-Close[i]) > (2*(Close[i]-Open[i]))))
{
Alert("Martillo invertido alcista");
return(14);
}
//Martillo invertido bajista
if((High[i] > Open[i]) && (Open[i] > Close[i]) &&
(Close[i] == Low[i]) &&
((High[i]-Open[i]) > (2*(Open[i]-Close[i]))))
{
Alert("Martillo invertido bajista");
return(15);
}
//Martillo alcista
if((High[i] == Close[i]) && (Close[i] > Open[i]) &&
(Open[i] > Low[i]) &&
((Open[i]-Low[i]) > (2*(Close[i]-Open[i]))))
{
Alert("Martillo alcista");
return(12);
}
//Martillo bajista
if((High[i] == Open[i]) && (Open[i] > Close[i]) &&
(Close[i] > Low[i]) &&
((Close[i]-Low[i]) > (2*(Open[i]-Close[i]))))
{
Alert("Martillo bajista");
return(11);
}
//Larga sombra superior alcista
if((High[i] > Close[i]) && (Close[i] > Open[i]) &&
(Open[i] > Low[i]) &&
((High[i]-Close[i]) > (3*(Close[i]-Open[i]))) &&
((Open[i]-Low[i]) < (Close[i]-Open[i]))) { Alert("Larga sombra superior alcista"); return(19); } //Larga sombra superior bajista if((High[i] > Open[i]) && (Open[i] > Close[i]) &&
(Close[i] > Low[i]) &&
((High[i]-Open[i]) > (3*(Open[i]-Close[i]))) &&
((Close[i]-Low[i]) < (Open[i]-Close[i]))) { Alert("Larga sombra superior bajista"); return(20); } //Larga sombra inferior alcista if((High[i] > Close[i]) && (Close[i] > Open[i]) &&
(Open[i] > Low[i]) &&
((High[i]-Close[i]) < (Close[i]-Open[i])) && ((Open[i]-Low[i]) > (3*(Close[i]-Open[i]))))
{
Alert("Larga sombra inferior alcista");
return(21);
}
//Larga sombra inferior bajista
if((High[i] > Open[i]) && (Open[i] > Close[i]) &&
(Close[i] > Low[i]) &&
((High[i]-Open[i]) < (Open[i]-Close[i])) && ((Close[i]-Low[i]) > (3*(Open[i]-Close[i]))))
{
Alert("Larga sombra inferior bajista");
return(22);
}
//Onda alta alcista
if((High[i] > Close[i]) && (Close[i] > Open[i]) &&
(Open[i] > Low[i]) &&
((High[i]-Close[i]) > (3*(Close[i]-Open[i]))) &&
((Open[i]-Low[i]) > (3*(Close[i]-Open[i]))))
{
Alert("Onda alta alcista");
return(23);
}
//Onda alta bajista
if((High[i] > Open[i]) && (Open[i] > Close[i]) &&
(Close[i] > Low[i]) &&
((High[i]-Open[i]) > (3*(Open[i]-Close[i]))) &&
((Close[i]-Low[i]) > (3*(Open[i]-Close[i]))) )
{
Alert("Onda alta bajista");
return(24);
}
//Peonza alcista
if((High[i] > Close[i]) && (Close[i] > Open[i]) &&
(Open[i] > Low[i]) &&
((High[i]-Close[i]) < (Close[i]-Open[i])) && ((Open[i]-Low[i]) < (Close[i]-Open[i])) && ((MathAbs(Close[i]-Open[i])) < (MathAbs(Close[i+1]-Open[i+1]))) && ((MathAbs(Close[i]-Open[i])) < (MathAbs(Close[i+2]-Open[i+2]))) && ((MathAbs(Close[i]-Open[i])) < (MathAbs(Close[i+3]-Open[i+3]))) ) { Alert("Peonza alcista"); return(8); } //Peonza bajista if((High[i] > Open[i]) && (Open[i] > Close[i]) &&
(Close[i] > Low[i]) &&
((High[i]-Open[i]) < (Open[i]-Close[i])) && ((Close[i]-Low[i]) < (Open[i]-Close[i])) && ((MathAbs(Close[i]-Open[i])) < (MathAbs(Close[i+1]-Open[i+1]))) && ((MathAbs(Close[i]-Open[i])) < (MathAbs(Close[i+2]-Open[i+2]))) && ((MathAbs(Close[i]-Open[i])) < (MathAbs(Close[i+3]-Open[i+3]))) ) { Alert("Peonza bajista"); return(7); } //Gran vela alcista if((High[i] > Close[i]) && (Close[i] > Open[i]) &&
(Open[i] > Low[i]) &&
((Close[i]-Open[i]) > (3*(High[i]-Close[i]))) &&
((Close[i]-Open[i]) > (3*(Open[i]-Low[i]))) &&
((MathAbs(Close[i]-Open[i])) > (3*(MathAbs(Open[i+1]-Close[i+1])))) &&
((MathAbs(Close[i]-Open[i])) > (3*(MathAbs(Open[i+2]-Close[i+2])))) &&
((MathAbs(Close[i]-Open[i])) > (3*(MathAbs(Open[i+3]-Close[i+3])))) )
{
Alert("Gran vela alcista");
return(9);
}
//Gran vela bajista
if((High[i] > Open[i]) && (Open[i] > Close[i]) &&
(Close[i] > Low[i]) &&
((Open[i]-Close[i]) > (3*(High[i]-Open[i]))) &&
((Open[i]-Close[i]) > (3*(Close[i]-Low[i]))) &&
((MathAbs(Close[i]-Open[i])) > (3*(MathAbs(Open[i+1]-Close[i+1])))) &&
((MathAbs(Close[i]-Open[i])) > (3*(MathAbs(Open[i+2]-Close[i+2])))) &&
((MathAbs(Close[i]-Open[i])) > (3*(MathAbs(Open[i+3]-Close[i+3])))) )
{
Alert("Gran vela bajista");
return(18);
}

return(0);
}


Como puedes observar en el código la función da una alerta cada vez que se produce una de las velas conocidas.

Esta función se debe de añadir en el código de nuestro indicador o de nuestro expert advisor, además se debería llamar a la función cada vez que se produce una nueva vela, pero también se puede obtener una vela determinada.

Este es una primera versión de la función, aún estoy comprobando dicha función en tiempo real, y me falta añadira alguna que otra cosa.

Saludos a todos.

jueves, 18 de junio de 2009

Como dibujar una linea en un grafico.

Saludos, llevaba tiempo sin escribir, pues estuve atareado con otras cosas.

Bien, no me olvidado del código para el EA d'Agostino, solo que lo he estado probando pero no da muy buenos resultados, todo será cuestión de paciencia.

Este post lo escribo por el echo de que he necesitado dibujar una línea al arrancar un expert advisor.

El siguiente código dibuja una línea Roja en el máximo del día anterior, y una línea verde en el mínimo del día anterior.

Bien lo primero es crear una función para dibujar una línea, navegando un poco por la página de MQL4, podemos encontrar un artículo donde se realiza esto, pongo a continuación la función que deberemos incluir en un archivo include.

int  maximosdiarios()
{
//Calculamos el máximo del día anterior
double precio=iHigh(Symbol(), PERIOD_D1,1);

//Dibujamos una línea roja

ObjectCreate("Maximo", OBJ_HLINE, 0, 0, precio);
ObjectSet("Maximo", OBJPROP_COLOR, Red);
ObjectSet("Maximo", OBJPROP_WIDTH, 3);

//Calculamos el mínimo del día anterior
price=iLow(Symbol(),PERIOD_D1,1);

//Dibujamos una línea verde
ObjectCreate("Minimo",OBJ_HLINE,0,0,precio);
ObjectSet("Minimo", OBJPROP_COLOR, Green);
ObjectSet("Minimo", OBJPROP_WIDTH, 3);

return(0);
}

Bien, esta función podemos ponerla en un archivo include o como una función dentro del EA o del indicador.

Tan solo nos hara falta llamar a la función dentro del expert advisor, como yo solo quiero dibujarla una sola vez al arrancar el EA, decidí poner la llamada a la función maximosdiarios() en la función init() del EA.

Tan solo mencionar que en el dinit() del EA se ha llamado a la función ObjectDeleteAll().

Saludos espero que os sea de utilidad, yo la emplearé más adelante en un EA.

lunes, 8 de junio de 2009

La importancia de la salida.

Ando un poco atareado, así que no tengo mucho tiempo para postear, pero he leído un artículo interesante en x-trader. Recomiendo su lectura.

En x-trader han publicado un artículo sobre como pueden variar las ganancias de un sistema sin tener en cuenta la entrada y tan solo estableciendo unos parámetros o reglas para la salida.

Dependiendo de las reglas de salida el sistema puede proporcionar diferentes ganancias.

Un saludo.

martes, 19 de mayo de 2009

Cruce de precio con una media

Este post lo escribo para contestar a un email recibido hace unos dias, siento no haber podido responder antes pero estuve de vacaciones.

En el email según entiendo se me pide un expert advisor para que nos avise de cuando el precio cruza una media LWMA.

La solución puesta a continuación es una de las múltiples que podríamos hacer, tampoco se si es exactamente lo que se me pidio en el email.

Para cambiar el período de la media tan solo hay que modificar la linea:

extern int media=15;

y poner el período que deseamos, es decir, si queremos una media de 100 cambiariamos el 15 por un 100.

//+------------------------------------------------------------------+
//| nuevo.mq4 |
//| Copyright © 2009, MetaQuotes Software Corp. |
//| http://www.metaquotes.net |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2009, Programar meta."
#property link "http://programarmeta.blogspot.com"

extern int periodo=15;
bool BarraNueva=false;

//+------------------------------------------------------------------+
//| expert initialization function |
//+------------------------------------------------------------------+
int init()
{
//----

//----
return(0);
}
//+------------------------------------------------------------------+
//| expert deinitialization function |
//+------------------------------------------------------------------+
int deinit()
{
//----

//----
return(0);
}
//+------------------------------------------------------------------+
//| expert start function |
//+------------------------------------------------------------------+
int start()
{
//----
double media=iMA(NULL, 0, periodo, 0, MODE_LWMA, PRICE_CLOSE,0);
Fun_NuevaBarra();
if(BarraNueva == 1)
{
if(((Open[1] <> media)) ||
((Close[2] <> media) && (Close[1] > media)))
Alert("Cruce hacia arriba");
if(((Open[1] > media) && (Close[1] <> media) && (Open[2] > media) &&
(Close[1] < nuevahora="0;" barranueva="false;" nuevahora="Time[0];" barranueva="true;">

Saludos a todos.

jueves, 16 de abril de 2009

Como mostrar información en MQL4.

Bueno, en este post voy a explicar las formas de las cuales disponemos en Metatrader para mostrar información, es decir que si se dan una serie de condiciones el programa nos muestre la información que deseamos.

El lenguaje MQL4 proporciona varios métodos para presentar información.
  • La función Alert visualiza una caja de diálogo con datos definidos por el usuario. El formato de dicha función es:

     Alert ( " El margen libre crece a", AccountFreeMargin (), "!"); 
  • La función Comment muestra los datos definidos por el usuario en la esquina superior izquierda de la gráfica. La secuencia de caracteres "\ n" se utiliza para iniciar una nueva línea.

     Comment ( " El margen libre es", AccountFreeMargin (), "."); 
  • La función Print guarda los datos definidos por el usuario en el registro del sistema.

     Print ( " El margen libre es", AccountFreeMargin (), "."); 
Existen otras formas de visualizar información pero en principio estas serían las mas usadas y las más sencillas.

Saludos a todos.

viernes, 10 de abril de 2009

Otro blog sobre metatrader.

Bueno, como ando un poco atareador ultimamente aquí os dejo un blog donde hay información sobre metatrader en español.

Aprendiendo de MQL4.

Gracias a la gente desisteresada, otros vamos aprendiendo cosas nuevas, por ello hay veces que coloco enlaces a otros blogs que voy encontrando por mis búsquedas en san google.

Sin el trabajo de esta gente desinteresada, a veces las cosas serían un poco mas complicadas de aprender y entender.

Gracias.

Saludos.

miércoles, 1 de abril de 2009

La función iMA de metatrader.

En este post voy a explicar un poco la función que trae el metatrader para obtener una media.

Podemos encontrarnos con distintos tipos de medias, por ejemplo:
  • Media simple, SMA.
  • Media exponencial, EMA.
  • Media alisada, WMA.
La función para obtener la media de una serie de valores es:

double iMA( string symbol, int timeframe, int period, int ma_shift, int ma_method, int applied_price, int shift)

Con esta función se calcula la media y retorna su valor.

Como se aprecia a la función se le pueden pasar varios parámetros:
  • El primero de ellos es el parámetro symbol, con este parámetro se puede especificar el símbolo al cual queremos realizarle la media, por ejemplo EUR/USD, si se le pasa NULL se realizaría sobre el símbolo actual.

  • El segúndo parámetro es el timeframe, es decir el período al cual se le realizará la media, pudiendo ser 5 minutos, 1 hora entre otros, si se le pasa 0 se utilizará el tiempo de la gráfica actual.

    PERIOD_M1 1 1 minute.
    PERIOD_M5 5 5 minutes.
    PERIOD_M15 15 15 minutes.
    PERIOD_M30 30 30 minutes.
    PERIOD_H1 60 1 hour.
    PERIOD_H4 240 4 hour.
    PERIOD_D1 1440 Daily.
    PERIOD_W1 10080 Weekly.
    PERIOD_MN1 43200 Monthly.
    0 (zero) 0 Timeframe used on the chart.

  • En el parámetro period, deberemos especificar el período de cálculo al cual deseamos realizar la media.

  • El parámetro ma_method, puede tomar los siguientes valores:


    MODE_SMA 0 Simple moving average
    MODE_EMA 1 Exponential moving average
    MODE_SMMA 2 Smoothed moving average,
    MODE_LWMA 3 Linear weighted moving average

  • El parámetro applied_price puede tomar los siguientes valores:

    PRICE_CLOSE 0 Close price.
    PRICE_OPEN 1 Open price.
    PRICE_HIGH 2 High price.
    PRICE_LOW 3 Low price.
    PRICE_MEDIAN 4 Median price, (high+low)/2.
    PRICE_TYPICAL 5 Typical price, (high+low+close)/3.
    PRICE_WEIGHTED 6 Weighted close price, (high+low+close+close)/4.

Tan solo quedaría poner un ejemplo de como calcular un par de medias, pero eso lo haré con algún caso práctico.

Saludos a todos.

viernes, 20 de marzo de 2009

Flujograma estrategia dagostino.

En un post anterior comenté que me daría un tiempo para probar una estrategia que encontré en la página web de fxstreet.es , pero como he tenido algo de tiempo me he dedicado ha hacer un flujograma del posible programa para desarrollar la estrategia, pues lo primero que debe plantearse un programador es diseñar el flujo del programa.

El siguiente gráfico muestra un posible planteamiento de dicho flujograma, en esto de la programación existen muchas formas de realizar las cosas así que esta ha sido la que se me ha ocurrido.


Para descargar la imagen pinchar aqui.
Puesto que el programa aún no está diseñado, cabe alguna posible modificación en el flujograma así que lo siguiente es realizar un pequeño flujograma con los datos de programación.

Bueno, saludos a todos mis seguidores, como siempre menciono estos programas no sirven para el trading real, así que no te fíes de ellos, yo solo los coloco en este blog por expresarme un poco, y tener un pequeño diario de mis andanzas por la programación y el trading.

Nota: Estos datos son solo educativos, no los uses para realizar trading real pues quizás llegues a arruinarte. Allá tú.

viernes, 13 de marzo de 2009

Estrategia D' Agostino

Bueno, despues de navegar bastante por internet, me doy cuenta que mis conocimientos sobre inversiones son infimos, quizás ni lleguen al 5% de lo que debería saber.

Despues de mucho navegar encontré una estrategia muy sencilla de aplicar, y que iré probando en una cuenta demo, puesto que no creo que dicha estrategia de muy buenos resultados, pero como he leído en varias páginas se trata de ir adquiriendo una metodología diaria e irse separando del miedo y de las emociones, a medida que la vaya realizando la iré programando, puesto que mis conocimientos de programación tambien son escasos, viendo EA de otros programadores.

Bueno, tiempo al tiempo, tan solo eso lo único que pierdo es tiempo y si llego a adquirir conocimientos sobre finanzas, pues muxo mejor.

La estrategia sobre la cual iré realizando mis primeras inversiones se encuentra en el siguiente enlace:

Tecnica D'agostino
.

Ojo, lo que podais leer en esta web no lo deberías aplicar con cuentas reales pues llegareis a perder todo vuestro capital. Estais avisados, solo pongo estos artículos por expresarme en algún medio de comunicación y tan solo con ánimo de tener diversidad de conocimientos.

La información siempre es buena, lo único que se pierde es el tiempo en adquirir dicha información.

Saludos a todos.

viernes, 27 de febrero de 2009

Un artículo interesante

Bien, posteo aquí la dirección de un artículo interesante que encontré en la página web: Tradingsys.

En este artículo habla de la colinealidad entre sistemas indicadores que se pueden utilizar en el trading.

Según entiendo por lo lo leído, viene a decir que no es necesario usar demasiados indicadores sino que es mejor utilizar indicadores con baja correlación entre ellos.

Bueno, si estas interesado te recomiendo que le eches un vistazo.

Saludos.

jueves, 19 de febrero de 2009

Blog de Blai5

Bien pongo aquí este post, puesto que he encontrado este blog que parece bastante interesante, segun cuenta el hombre se dedica ha realizar indicadores para el prorealtime y el visualchart.

Los indicadores que he visto parecen interesantes, así que os dejo el enlace para que podais comprobar por vosotros mismos dichos indicadores.

Lo cierto es que mis conocimientos de bolsa y de programación con respecto a este tipo de gente son mínimos, así que tengo que seguir estudiando y aprendiendo de estos privilegiados.

El enlace al post es

http://www.blai5.net/


Saludos.

sábado, 14 de febrero de 2009

Gran vela alcista con banda bollinger.

Bien, este programa me vino a la idea despues de haber observado una gráfica en la que una gran vela alcista se producia por debajo de la banda de bollinger inferior, tras producirse esta vela y con la confirmación de una apertura por encima del cierre se produjo un rallye alcista, bueno esto tan solo ocurrió en una gráfica.

REM Banda de bolinger inferior
indicator1 = BollingerDown[20](Close)

REM Gran vela bajista
c111=((High[0] >= Close[0]) AND (Close[0] > Open[0]) AND (Open[0] >= Low[0]))
c42=((High[0] <>

Ojo la apertura de la siguiente vela se tiene que producir por encima del cierre y se entraría al mercado al superar la entrada, el stop loss se deberá colocar encima del cierre de la gran vela blanca.

Bien, falta que se confirme en otra gráfica pero por si las moscas queda programada para su prueba.

Gran vela alcista.

Bueno esta es otra pauta para tener en cuenta según el manual de candlestick.

Por lo tanto vamos a realizar el programa.

ONCE velalarga=2

REM Gran vela bajista
c111=((High[0] >= Close[0]) AND (Close[0] > Open[0]) AND (Open[0] >= Low[0]) AND (ABS(Close - Open) > AverageTrueRange[14](Close)/velalarga))

IF c111 THEN
BUY 1 SHARES AT MARKET
ENDIF


Bueno, al igual que con la vela bajista se producen demasiadas entradas, cuestion de estudiar el mercado.

Habra que aplicar un filtro, pero eso para otro post.

Gran vela bajista.

Bien realizaré mi primer programilla con la plataforma prorealtime.

Según la documentación de manual de candlestick del Ustinpower, esta vela es para un patrón de confirmación cuando hay una tendencia bajista, su fiabilidad es alta empleada con otras velas del mercado.

Para considerar a la vela como una gran vela bajista se estaría hablando que debería ser al menos 3 veces superior a la media de las velas negras habituales.

Una gran vela negra implica una gran fuerza bajista, con lo que su cuerpo real actuará de resistencia. Normalmente la resistencia viene dada hasta la mitad del cuerpo real.

La programación es bastante sencilla, la he realizado en el probacktest pues es aquí donde aprenderemos si se cumple la teoría:

ONCE velalarga=2

REM Gran vela bajista
c110=((High[0] >= Open[0]) AND (Open[0] > Close[0]) AND (Close[0] >= Low[0]) AND (ABS(Close - Open) > AverageTrueRange[14](Close)/velalarga))

IF c110 THEN
SELLSHORT 1 SHARES AT MARKET THISBARONCLOSE
ENDIF


Como puedes apreciar la variable velalarga no muestra el tamaño de la vela con respecto a las otras 14 anteriores, usada en la funcion AverageTrueRange que calcula el rango medio de las ultimas velas.

Tras varias pruebas el sistema da bastante señales de entrada. Por lo tanto, tendré que aplicar un filtro para no entrar tanto. Si se pone un velalarga igual a 1 el sistema da menos entradas y la mañoría ganadoras con un profit stop al 2%.

Bueno en principio sería buena pero habrá que diseñarle un filtro, pero eso para otro post.

Gran vela bajista.

Cambio de plataforma de programacion

Bueno se que empecé este post por poner aquí mis programas con metatrader, pero tras averiguar un par de cosas por la red, y puesto que en españa no hay ningun broker que use esta plataforma, o de momento no lo he encontrado, voy a empezar a hacer mis pinillos con otra plataforma de programación denominada prorealtime, puesto que esta plataforma es muy parecida sino la misma que usan los dos bancos en los cuales ha decidido mi hermano hacer operaciones en bolsa. Estos bancos son self trader y banca march.

Bueno esta plataforma no es tan potente en el lenguaje de programación, pero la imaginación lo hace todo, el lenguaje de programación es un sistema muy parecido al basic con ciertas restricciones, bueno todo se andará.

Bien para no aburrir demasiado se puede visitar la página de prorealtime.

Saludos, si tengo tiempo iré colgando mis programillas de entretenimiento con la plataforma, no te llegarás ha hacer rico pues tan solo son programas para aprender.

miércoles, 4 de febrero de 2009

Comprobar tendencia alcista en 3 velas.

Con este programa se pretende comprobar si existe una tendencia alcista en las ultimas tres velas, si es así se dará una alarma.

Para ello usaremos el programa anterior de mostrar una vela, y al detectar una nueva vela comprobaremos las tres anteriores.

Hay que hacer notar que existirá una tendencia alcista cuando se den tres mínimos consecutivos.


//+------------------------------------------------------------------+

//| Velas.mq4 |
//| Copyright © 2009, Saludante |
//| http:// |
//+------------------------------------------------------------------+
#property copyright "Saludante"
#property link "http://"


//+------------------------------------------------------------------+
//|Inicializacion de variables |
//+------------------------------------------------------------------+

//Variable que detecta una vela nueva

bool BarraNueva=false;

//+------------------------------------------------------------------+
//| expert initialization function |
//+------------------------------------------------------------------+
int init()
{
return;
}

//+------------------------------------------------------------------+
//| expert deinitialization function |
//+------------------------------------------------------------------+
int deinit()
{
//----

//----
return(0);
}

//+------------------------------------------------------------------+
//| expert start function |
//+------------------------------------------------------------------+
int start()
{

//--------------------------------------------------------------------
Fun_NuevaBarra(); // Nueva vela
if (BarraNueva==false)
{
return;
}

if((Low[4] < Low[3]) && (Low[3] < Low[2]) && (Low[2] < Low[1]))
{
Alert("Tendencia previa ALCISTA");
return;
}


return;
}

//--------------------------------------------------------------------
//Funcion que detecta una nueva barra.

void Fun_NuevaBarra()
{
static datetime NuevaHora=0; // Deteccion nueva hora
BarraNueva=false; // 0 - misma vela ; 1- vela nueva
if(NuevaHora!=Time[0]) // Si el hora es cero comienza vela
{
NuevaHora=Time[0];
BarraNueva=true;
}
}

Saludos.

martes, 3 de febrero de 2009

Avisar cuando se produce una vela.

Bien este primer programa nos servirá para avisarnos de cuando se produce una vela en el gráfico donde se introduzca el expert advisor.

El programa es muy sencillo y tan solo nos dará un aviso de cuando se produzca el cambio a una nueva vela en la gráfica.


//+------------------------------------------------------------------+
//| Velas.mq4 |
//| Copyright © 2009, Saludante |
//| http:// |
//+------------------------------------------------------------------+
#property copyright "Saludante"
#property link "http://"


//+------------------------------------------------------------------+
//|Inicializacion de variables |
//+------------------------------------------------------------------+

bool BarraNueva=false; //Variable que detecta una vela nueva

//+------------------------------------------------------------------+
//| expert initialization function |
//+------------------------------------------------------------------+
int init()
{
return;
}

//+------------------------------------------------------------------+
//| expert deinitialization function |
//+------------------------------------------------------------------+
int deinit()
{
//----

//----
return(0);
}

//+------------------------------------------------------------------+
//| expert start function |
//+------------------------------------------------------------------+
int start()
{

//--------------------------------------------------------------------
Fun_NuevaBarra(); // Nueva vela
if (BarraNueva==false)
{
return;
}

return;
}

//--------------------------------------------------------------------
//Funcion que detecta una nueva barra.

void Fun_NuevaBarra()
{
static datetime NuevaHora=0; // Deteccion nueva hora
BarraNueva=false; // 0 - misma vela ; 1- vela nueva
if(NuevaHora!=Time[0]) // Si el hora es cero comienza vela
{
NuevaHora=Time[0];
BarraNueva=true;
Alert("Barra nueva"); //Avisa de una barra nueva
}
}



Saludos.

domingo, 1 de febrero de 2009

Saludos a todos los que programan.

Bueno comienzo este blog por motivos personales, pues visto que no he encontrado demasiado información en español sobre como programar en metatrader, puesto que la mayoría de programas que se encuentran para esta aplicación suelen estar en otros idiomas, espero no incumplir ninguna de las reglas de copyrithg de dichos programas.

Puesto que mi ingles no es muy bueno, trataré de realizar diversos experimentos con las funciones de la aplicación y pondré mis experiencias sobre dichas funciones.

Por qué comienzo este blog, por el echo de que me gusta la programación y como mi hermano se empezó a introducir en bolsa y vió que había gente que realizaba robots para detectar señales de compra y venta, me empezó a picar la curiosidad.

Mis conocimientos de programación son bastantes flojos y los de ingles también así que si encontrais algún fallo os pido perdón por adelantado, y no dudeis poneros en contacto con los comentarios.

Antetodo teneis muxa información en la página web de metatrader.

La información que encontreis en este blog no te hará rico, y lo mas probable es que en la mayoría de entradas al mercado suelas perder dinero, así que no hagas lo que se pone aquí, este blog solo lo realizo como expansión personal y para detallar mis escasos conocimientos de bolsa y de programación, si tienes alguna pega deja algún comentario.

Los programas que aquí encuentres tan solo son como experiencia personal en mis tradeos.