Saltar a contenido

Crear un cBot en cTrader

Este artículo describe los pasos para crear un robot de operaciones para operaciones algorítmicas en Python o C#, implementar el robot y ejecutarlo en cTrader.

Consejo

Con cTrader Windows o Mac, puede crear robots de operaciones rápidamente u obtener asistencia de IA.

En la pestaña cBots de la aplicación Algo, haga clic en el botón Nuevo para abrir el asistente de creación de algoritmos.

Introduzca un nombre para su cBot y, a continuación, seleccione un lenguaje de programación entre C# y Python.

Elija un método de creación entre:

  • Desde cero: el nuevo robot de operaciones solo contendrá una plantilla básica.

  • Usando una plantilla: podrá seleccionar un algoritmo prefabricado de una lista de plantillas de Python# o C#, que cubren una amplia gama de tipos de cBot y acciones de operaciones automatizadas.

Nota

Los algoritmos prefabricados ya contienen lógica de operaciones y parámetros personalizables. Estos cBots están listos para ejecutarse una vez que los guarde y compile.

Después de hacer clic en Crear, se abre el editor de código y puede comenzar a editar el código del robot de operaciones.

Editar el código

Dependiendo del método de creación que haya elegido, el ejemplo de robot de operaciones contiene uno o más de los siguientes elementos:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
[Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
public class SupercBot : Robot
{
    // === Fields ===
    // Declare indicators, variables or parameters, state flags, etc. here

    protected override void OnStart()
    {
        // Called once when the cBot starts
        // Initialize indicators, variables, parameters, or subscribe to events
    }

    protected override void OnTick()
    {
        // Called on every market tick
        // Useful for high-frequency strategies (but may be CPU-intensive)
    }

    protected override void OnBar()
    {
        // Called at the start of each new bar (candle)
        // Preferred for most strategies to reduce CPU load
    }

    protected override void OnStop()
    {
        // Called when the cBot is stopped
        // Useful for cleanup, logging, or resetting state
    }

    // === Custom Methods ===
    // Add your own helper methods below to modularize your logic

    private void ExampleMethod()
    {
        // A placeholder for your custom logic (e.g., strategy evaluation)
    }

    private void ClosePositions()
    {
        // Example of a method that could close open positions
    }

    private bool CheckCondition()
    {
        // Example of a method that could return a boolean condition
        return false;
    }
}

El atributo Robot del cBot junto con sus propiedades opcionales como TimeZone y AccessRights, precede a la declaración de la clase cBot (SupercBot).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
class SupercBot():
    # === Fields ===
    # Declare indicators, variables, state flags, etc. here
    # self.example_indicator = None
    # self.some_flag = True

    def on_start(self):
        # Called once when the cBot starts
        # Initialize indicators, variables, parameters, or subscribe to events
        pass

    def on_tick(self):
        # Called on every market tick
        # Useful for high-frequency strategies (but may be CPU-intensive)
        pass

    def on_bar_closed(self):
        # Called at the start of each new bar (candle)
        # Preferred for most strategies to reduce CPU load
        pass

    def on_stop(self):
        # Called when the cBot is stopped
        # Useful for cleanup, logging, or resetting state
        pass

    # === Custom Methods ===
    # Add your own helper methods below to modularize your logic

    def example_method(self):
        # A placeholder for your custom logic (e.g., strategy evaluation)
        pass

    def close_positions(self):
        # Example of a method that could close open positions
        pass

    def check_condition(self):
        # Example of a method that could return a boolean condition
        return False

Estos métodos suelen incluirse por defecto:

  • El método on_start se invoca cada vez que se inicia una instancia de su cBot.
  • El método OnTick() se invoca en cada tick.
  • El método OnBar() se invoca en cada barra.
  • El método OnStop() se invoca cada vez que una instancia de su nuevo cBot deja de funcionar.

El método OnTick() realiza una determinada acción en cada tick, lo que lo hace intensivo en cuanto a CPU. En muchos casos de operaciones, hay poca necesidad de realizar operaciones de negociación en cada tick. Usar el método OnBar() es más práctico.

Los métodos y tipos de código mostrados en el fragmento de ejemplo anterior no son la única forma de configurar y establecer el comportamiento de un bot. Sin embargo, son los más fáciles de usar si está empezando con la programación. Para aprender más sobre algoritmos, comience con los fundamentos de C# y explore ejemplos de código de cBot.

Nota

Referencias incluye todas las clases, eventos, métodos, variables, etc. para crear algoritmos en cTrader, mientras que los ejemplos completos de algoritmos y plantillas están disponibles en un repositorio de GitHub.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
class SupercBot():
    # === Fields ===
    # Declare indicators, variables, state flags, etc. here
    # self.example_indicator = None
    # self.some_flag = True

    def on_start(self):
        # Called once when the cBot starts
        # Initialize indicators, variables, parameters, or subscribe to events
        pass

    def on_tick(self):
        # Called on every market tick
        # Useful for high-frequency strategies (but may be CPU-intensive)
        pass

    def on_bar_closed(self):
        # Called at the start of each new bar (candle)
        # Preferred for most strategies to reduce CPU load
        pass

    def on_stop(self):
        # Called when the cBot is stopped
        # Useful for cleanup, logging, or resetting state
        pass

    # === Custom Methods ===
    # Add your own helper methods below to modularize your logic

    def example_method(self):
        # A placeholder for your custom logic (e.g., strategy evaluation)
        pass

    def close_positions(self):
        # Example of a method that could close open positions
        pass

    def check_condition(self):
        # Example of a method that could return a boolean condition
        return False

Estos métodos suelen incluirse por defecto:

  • El método on_start se invoca cada vez que se inicia una instancia de su cBot.
  • El método on_tick se invoca en cada tick.
  • El método on_bar_closed se invoca en cada barra.
  • El método on_stop se invoca cada vez que una instancia de su nuevo cBot deja de funcionar.

El método on_tick realiza una determinada acción en cada tick, lo que lo hace intensivo en cuanto a CPU. En muchos casos de operaciones, hay poca necesidad de realizar operaciones de negociación en cada tick. Es más práctico utilizar el método on_bar_closed.

Los métodos y tipos de código mostrados en el fragmento de ejemplo anterior no son la única forma de configurar y establecer el comportamiento de un cBot. Sin embargo, son los más fáciles de usar si está empezando con la programación. Para aprender más sobre algoritmos, comience con los fundamentos de Python y explore ejemplos de código de cBot.

Aplique sus nuevos conocimientos para editar el código del robot de operaciones y adaptarlo a sus necesidades.

Guardar y compilar

Guarde su código haciendo clic en el botón Guardar en la parte superior del editor de código o utilice el atajo Ctrl+S.

Antes de poder utilizar su cBot, necesita validar su código compilando el proyecto del cBot. Haga clic en el botón Compilar en la parte superior del editor de código o pulse Ctrl+B.

Guarde su código haciendo clic en el icono Guardar en la parte superior del editor de código o utilice el atajo Cmd+S.

Antes de poder utilizar su cBot, necesita validar su código compilando el proyecto del cBot. Haga clic en el icono Compilar en la parte superior del editor de código o pulse Cmd+B.

Cuando la compilación se realiza con éxito, verá un mensaje de confirmación en Resultado de la compilación. Si la compilación falla, aparecerá en su lugar un resumen de todos los errores encontrados.

Si hay cambios en el código desde la última compilación, aparecerá un asterisco junto al icono Compilar. En este caso, debe compilar el cBot de nuevo antes de iniciar una instancia del mismo.

Una vez que compile con éxito un cBot, el cBot estará listo para la acción, pero solo comenzará a funcionar cuando inicie una instancia.

Image title