Trechos de Código NTSL: Exemplos Práticos para Trading

Por que Usar Trechos de Código Prontos?

Criar robôs do zero é trabalhoso. Usar trechos de código testados e funcionando acelera o desenvolvimento e reduz erros. Esta coleção reúne padrões comuns que você pode copiar, adaptar e combinar para criar seus próprios robôs.

Cada trecho é independente e pode ser usado sozinho ou combinado com outros. Eles são como peças de LEGO - você monta o que precisa.

Padrão 1: Detecção de Cruzamento de Médias Móveis

Um dos padrões mais comuns em trading. Detecta quando uma média rápida cruza acima ou abaixo de uma média lenta.

// Parâmetros
periodo_rapida = 9;
periodo_lenta = 21;

// Variáveis
media_rapida = 0;
media_lenta = 0;
cruzou_cima = false;
cruzou_baixo = false;

tick()
{
    // Calcular médias
    media_rapida = MediaMovel(periodo_rapida, Fechamento);
    media_lenta = MediaMovel(periodo_lenta, Fechamento);
    
    // Detectar cruzamento para cima (compra)
    cruzou_cima = (media_rapida > media_lenta) e (media_rapida[1] <= media_lenta[1]);
    
    // Detectar cruzamento para baixo (venda)
    cruzou_baixo = (media_rapida < media_lenta) e (media_rapida[1] >= media_lenta[1]);
    
    // Usar sinais
    se(cruzou_cima)
    {
        Escrever("Cruzamento para cima detectado");
        // Sua lógica de compra aqui
    }
    
    se(cruzou_baixo)
    {
        Escrever("Cruzamento para baixo detectado");
        // Sua lógica de venda aqui
    }
}

Padrão 2: Filtro RSI para Confirmar Entradas

Usa RSI para evitar entrar em condições de sobrecompra/sobrevenda extremas.

// Parâmetros
periodo_rsi = 14;
nivel_sobrevenda = 30;
nivel_sobrecompra = 70;

// Variáveis
rsi_atual = 0;

tick()
{
    rsi_atual = RSI(periodo_rsi);
    
    // Filtro para compra: RSI não deve estar sobrecomprado
    pode_comprar = (rsi_atual < nivel_sobrecompra);
    
    // Filtro para venda: RSI não deve estar sobrevendido
    pode_vender = (rsi_atual > nivel_sobrevenda);
    
    // Usar filtros
    se(pode_comprar e outras_condicoes_compra)
    {
        // Compra permitida
    }
    
    se(pode_vender e outras_condicoes_venda)
    {
        // Venda permitida
    }
}

Padrão 3: Stop Loss com Break Even Automático

Move stop loss para break even quando posição atinge lucro mínimo.

// Parâmetros
stop_loss_inicial = 50;
lucro_para_break_even = 30;
distancia_break_even = 5; // Margem de segurança

// Variáveis
stop_loss_atual = 0;
break_even_ativado = false;

tick()
{
    se(PosicaoAberta())
    {
        preco_entrada = PrecoEntrada();
        preco_atual = Fechamento;
        
        se(TipoPosicao() == "COMPRA")
        {
            lucro_pontos = preco_atual - preco_entrada;
            
            // Ativar break even após lucro mínimo
            se(lucro_pontos >= lucro_para_break_even e nao break_even_ativado)
            {
                stop_loss_atual = preco_entrada + distancia_break_even;
                break_even_ativado = true;
                Escrever("Break even ativado em " + stop_loss_atual);
            }
            
            // Verificar stop loss
            se(break_even_ativado)
            {
                se(preco_atual <= stop_loss_atual)
                {
                    FecharPosicao();
                    Escrever("Break even acionado");
                }
            }
            senao
            {
                // Stop loss inicial
                se(lucro_pontos <= -stop_loss_inicial)
                {
                    FecharPosicao();
                    Escrever("Stop loss inicial acionado");
                }
            }
        }
    }
    senao
    {
        break_even_ativado = false;
    }
}

Padrão 4: Trailing Stop Progressivo

Trailing stop que aumenta a distância conforme o lucro cresce.

// Parâmetros
trailing_inicial = 20;
trailing_maximo = 50;
incremento_trailing = 5;
lucro_para_ativar = 30;

// Variáveis
melhor_preco = 0;
trailing_atual = trailing_inicial;

tick()
{
    se(PosicaoAberta())
    {
        preco_entrada = PrecoEntrada();
        preco_atual = Fechamento;
        
        se(TipoPosicao() == "COMPRA")
        {
            lucro_pontos = preco_atual - preco_entrada;
            
            // Atualizar melhor preço
            se(preco_atual > melhor_preco)
            {
                melhor_preco = preco_atual;
            }
            
            // Ativar trailing após lucro mínimo
            se(lucro_pontos >= lucro_para_ativar)
            {
                // Aumentar trailing conforme lucro cresce
                novo_trailing = trailing_inicial + (lucro_pontos / 10) * incremento_trailing;
                
                se(novo_trailing > trailing_maximo)
                {
                    novo_trailing = trailing_maximo;
                }
                
                trailing_atual = novo_trailing;
                
                // Calcular nível do trailing stop
                nivel_trailing = melhor_preco - trailing_atual;
                
                // Verificar se preço caiu até trailing
                se(preco_atual <= nivel_trailing)
                {
                    FecharPosicao();
                    Escrever("Trailing stop progressivo acionado. Lucro: " + lucro_pontos);
                }
            }
        }
    }
    senao
    {
        melhor_preco = 0;
        trailing_atual = trailing_inicial;
    }
}

Padrão 5: Filtro de Volume

Evita operar em períodos de baixa liquidez.

// Parâmetros
volume_minimo = 1000;
periodo_media_volume = 20;

// Variáveis
volume_atual = 0;
media_volume = 0;

tick()
{
    volume_atual = Volume;
    media_volume = MediaMovel(periodo_media_volume, Volume);
    
    // Filtro: volume atual deve ser maior que média
    volume_suficiente = (volume_atual > media_volume);
    
    // Ou usar volume mínimo absoluto
    volume_suficiente_absoluto = (volume_atual > volume_minimo);
    
    // Combinar filtros
    pode_operar = volume_suficiente e volume_suficiente_absoluto;
    
    se(pode_operar e outras_condicoes)
    {
        // Operação permitida
    }
}

Padrão 6: Filtro de Horário

Restringe operações a horários específicos do pregão.

// Parâmetros
hora_inicio = 10; // 10:00
hora_fim = 16; // 16:00
minuto_inicio = 0;
minuto_fim = 0;

// Variáveis
hora_atual = 0;
minuto_atual = 0;

tick()
{
    hora_atual = HoraAtual();
    minuto_atual = MinutoAtual();
    
    // Converter para minutos desde meia-noite para facilitar comparação
    minutos_atual = hora_atual * 60 + minuto_atual;
    minutos_inicio = hora_inicio * 60 + minuto_inicio;
    minutos_fim = hora_fim * 60 + minuto_fim;
    
    // Verificar se está no horário permitido
    no_horario = (minutos_atual >= minutos_inicio) e (minutos_atual <= minutos_fim);
    
    // Evitar pré-abertura e after market
    evitar_pre_abertura = (minutos_atual >= 600); // Após 10:00
    evitar_after_market = (minutos_atual <= 1020); // Antes de 17:00
    
    pode_operar = no_horario e evitar_pre_abertura e evitar_after_market;
    
    se(pode_operar e outras_condicoes)
    {
        // Operação permitida
    }
}

Padrão 7: Múltiplas Confirmações para Entrada

Combina vários indicadores para aumentar confiabilidade do sinal.

// Parâmetros
periodo_media = 20;
periodo_rsi = 14;
periodo_macd_rapido = 12;
periodo_macd_lento = 26;
periodo_macd_sinal = 9;

// Variáveis
media = 0;
rsi = 0;
macd_linha = 0;
macd_sinal = 0;
macd_histograma = 0;

tick()
{
    // Calcular indicadores
    media = MediaMovel(periodo_media, Fechamento);
    rsi = RSI(periodo_rsi);
    macd_linha = MACD(periodo_macd_rapido, periodo_macd_lento, periodo_macd_sinal);
    macd_sinal = MACDSinal(periodo_macd_rapido, periodo_macd_lento, periodo_macd_sinal);
    macd_histograma = MACDHistograma(periodo_macd_rapido, periodo_macd_lento, periodo_macd_sinal);
    
    // Condições para compra (todas devem ser verdadeiras)
    condicao1 = Fechamento > media; // Preço acima da média
    condicao2 = rsi > 50 e rsi < 70; // RSI em zona neutra/forte
    condicao3 = macd_linha > macd_sinal; // MACD positivo
    condicao4 = macd_histograma > macd_histograma[1]; // MACD acelerando
    
    // Sinal de compra com múltiplas confirmações
    sinal_compra = condicao1 e condicao2 e condicao3 e condicao4;
    
    // Condições para venda
    condicao1_venda = Fechamento < media;
    condicao2_venda = rsi < 50 e rsi > 30;
    condicao3_venda = macd_linha < macd_sinal;
    condicao4_venda = macd_histograma < macd_histograma[1];
    
    sinal_venda = condicao1_venda e condicao2_venda e condicao3_venda e condicao4_venda;
    
    // Usar sinais
    se(sinal_compra e nao PosicaoAberta())
    {
        Comprar(1);
        Escrever("Compra com múltiplas confirmações");
    }
    
    se(sinal_venda e nao PosicaoAberta())
    {
        Vender(1);
        Escrever("Venda com múltiplas confirmações");
    }
}

Padrão 8: Cálculo de Quantidade Baseado em Risco

Calcula quantidade automaticamente baseado no risco desejado.

// Parâmetros
risco_percentual = 1.0; // 1% do capital por operação
stop_loss_pontos = 50;
valor_por_ponto = 1.0; // Para WIN = R$ 1 por ponto

// Variáveis
capital_total = 0;
risco_maximo_reais = 0;
quantidade_calculada = 0;

inicio()
{
    // Obter capital total (ajustar conforme plataforma)
    capital_total = 10000; // Exemplo: R$ 10.000
    risco_maximo_reais = capital_total * (risco_percentual / 100);
}

tick()
{
    // Calcular quantidade baseada em risco
    risco_por_contrato = stop_loss_pontos * valor_por_ponto;
    quantidade_calculada = risco_maximo_reais / risco_por_contrato;
    
    // Arredondar para baixo (ser conservador)
    quantidade_calculada = Floor(quantidade_calculada);
    
    // Garantir mínimo de 1 contrato
    se(quantidade_calculada < 1)
    {
        quantidade_calculada = 1;
    }
    
    // Usar quantidade calculada
    se(sinal_entrada)
    {
        Comprar(quantidade_calculada);
        Escrever("Quantidade calculada: " + quantidade_calculada);
    }
}

Padrão 9: Limite de Operações por Dia

Evita overtrading limitando número de operações.

// Parâmetros
max_operacoes_dia = 5;

// Variáveis
operacoes_hoje = 0;
data_atual = 0;
ultima_data = 0;

inicio()
{
    data_atual = DataAtual();
    ultima_data = data_atual;
}

tick()
{
    // Reset diário
    se(data_atual != ultima_data)
    {
        operacoes_hoje = 0;
        ultima_data = data_atual;
        Escrever("Novo dia. Reset contador de operações.");
    }
    
    // Verificar limite
    se(operacoes_hoje >= max_operacoes_dia)
    {
        Escrever("Limite de operações diárias atingido: " + max_operacoes_dia);
        retornar; // Não executa lógica de entrada
    }
    
    // Lógica de entrada
    se(sinal_entrada e nao PosicaoAberta())
    {
        Comprar(1);
        operacoes_hoje = operacoes_hoje + 1;
        Escrever("Operação " + operacoes_hoje + " de " + max_operacoes_dia);
    }
}

Padrão 10: Detecção de Tendência com Múltiplos Timeframes

Confirma tendência verificando múltiplos timeframes.

// Parâmetros
periodo_media = 20;

// Nota: Acesso a múltiplos timeframes depende da plataforma
// Este é um exemplo conceitual

tick()
{
    // Calcular médias em diferentes timeframes
    // (Ajustar conforme API da plataforma)
    
    media_1min = MediaMovel(periodo_media, Fechamento); // 1 minuto
    media_5min = MediaMovel(periodo_media, Fechamento); // 5 minutos (se disponível)
    media_15min = MediaMovel(periodo_media, Fechamento); // 15 minutos (se disponível)
    
    // Tendência de alta: todas as médias alinhadas para cima
    tendencia_alta = (Fechamento > media_1min) e (media_1min > media_5min) e (media_5min > media_15min);
    
    // Tendência de baixa: todas as médias alinhadas para baixo
    tendencia_baixa = (Fechamento < media_1min) e (media_1min < media_5min) e (media_5min < media_15min);
    
    // Operar apenas a favor da tendência
    se(tendencia_alta e sinal_compra)
    {
        Comprar(1);
    }
    
    se(tendencia_baixa e sinal_venda)
    {
        Vender(1);
    }
}

Como Combinar Padrões

Você pode combinar múltiplos padrões para criar robôs mais robustos:

// Exemplo: Combinando vários padrões
tick()
{
    // 1. Filtro de horário
    no_horario = VerificarHorario();
    
    // 2. Filtro de volume
    volume_ok = VerificarVolume();
    
    // 3. Múltiplas confirmações
    sinal_valido = VerificarConfirmacoes();
    
    // 4. Limite de operações
    pode_operar_hoje = VerificarLimiteOperacoes();
    
    // 5. Calcular quantidade baseada em risco
    quantidade = CalcularQuantidade();
    
    // Combinar todos os filtros
    se(no_horario e volume_ok e sinal_valido e pode_operar_hoje)
    {
        Comprar(quantidade);
        
        // 6. Aplicar stop loss e trailing stop
        ConfigurarStopLoss();
        ConfigurarTrailingStop();
    }
}

Conclusão: Construindo com Blocos

Estes trechos são blocos de construção. Use-os sozinhos ou combine-os para criar robôs mais complexos e robustos.

Lembre-se: sempre teste em simulação antes de usar em conta real. Adapte os códigos às suas necessidades e à sua estratégia.

Com estes padrões, você tem uma base sólida para criar robôs profissionais. Comece simples, adicione complexidade gradualmente e teste muito.

Artigos Relacionados

Ver todos os posts