Manual NTSL: Sintaxe e Funções Essenciais para Trading

Introdução ao NTSL

NTSL (Profit Trading Script Language) é a linguagem de programação nativa do Profit Pro. Foi desenvolvida especificamente para traders, com sintaxe simples e funções prontas para operações financeiras. Você não precisa ser programador experiente para usar NTSL - a linguagem foi pensada para ser intuitiva.

E isso é uma grande vantagem. Porque muitas linguagens de programação são complexas, com conceitos abstratos que não fazem sentido para traders. Mas NTSL foi criado pensando em traders. As funções têm nomes que fazem sentido no contexto de trading. A sintaxe é simples e direta. E você não precisa entender conceitos avançados de programação para começar a usar.

Este manual cobre os fundamentos essenciais. Com este conhecimento, você consegue ler, entender e modificar robôs existentes, além de criar seus próprios robôs do zero. E isso é poderoso, porque quando você entende NTSL, você não depende mais de outros para implementar suas ideias. Você pode criar, testar e ajustar suas próprias estratégias.

Mas é importante entender que este manual cobre os fundamentos. NTSL tem muito mais recursos do que o que está aqui. Mas com os fundamentos, você já consegue fazer muito. E conforme você ganha experiência, você naturalmente aprende recursos mais avançados. Não precisa aprender tudo de uma vez.

Estrutura Básica de um Script NTSL

Todo script NTSL segue uma estrutura básica. E entender essa estrutura é fundamental, porque todos os robôs seguem esse padrão. Uma vez que você entende a estrutura, ler e escrever código fica muito mais fácil.

A estrutura básica tem três partes principais. Primeiro, você define variáveis globais no início do arquivo. Essas são variáveis que podem ser usadas em qualquer parte do código. Segundo, você tem a função inicio(), que é executada uma vez quando o robô é ativado. E terceiro, você tem a função tick(), que é executada a cada movimento de preço, permitindo que o robô monitore o mercado em tempo real.

// Comentários começam com //
// Definição de variáveis globais
variavel_global = valor;

// Função de inicialização (executada uma vez)
inicio()
{
    // Código de inicialização
}

// Função principal (executada a cada tick)
tick()
{
    // Lógica principal do robô
}

Essa estrutura é simples, mas poderosa. A função inicio() é onde você faz configurações iniciais, cálculos que só precisam ser feitos uma vez, ou inicializações de variáveis. A função tick() é onde acontece a mágica - é onde você monitora o mercado, calcula indicadores, toma decisões e executa ordens. E essa função é chamada automaticamente a cada movimento de preço, garantindo que seu robô esteja sempre atualizado.

Tipos de Dados

NTSL trabalha com tipos de dados simples. E isso é uma vantagem, porque você não precisa se preocupar com tipos complexos. A linguagem é flexível e geralmente trata os dados de forma intuitiva.

Números

NTSL trabalha com números de forma flexível. Você pode usar inteiros como 10, -5, 100. Esses são números sem casas decimais, úteis para contadores, quantidades, ou valores que não precisam de precisão decimal.

Você também pode usar decimais como 10.5, 3.14, -2.5. Esses são números com casas decimais, essenciais para trabalhar com preços, que geralmente têm casas decimais. E NTSL trata números de forma flexível, então você não precisa se preocupar muito com conversões de tipo. Se você usar um número inteiro onde é esperado um decimal, geralmente funciona. E vice-versa.

Isso torna a programação mais simples, porque você não precisa pensar constantemente sobre tipos de dados. Você apenas usa os números, e NTSL faz o trabalho de conversão quando necessário.

Texto (Strings)

Strings são sequências de caracteres, usadas para mensagens, nomes, ou qualquer texto. Em NTSL, você define strings usando aspas duplas. Por exemplo, mensagem = "Olá, mundo!"; cria uma variável chamada mensagem com o texto "Olá, mundo!". Ou nome_robo = "Robô SMC"; cria uma variável com o nome do robô.

Strings são úteis para debug, para mensagens de log, ou para identificar diferentes robôs ou estratégias. E NTSL permite que você concatene strings (juntar duas strings), o que é útil para criar mensagens dinâmicas.

Booleanos (Verdadeiro/Falso)

Booleanos são valores que podem ser apenas verdadeiro ou falso. Em NTSL, você usa as palavras verdadeiro e falso (em português). Por exemplo, posicao_aberta = verdadeiro; indica que há uma posição aberta. Ou pode_operar = falso; indica que o robô não pode operar no momento.

Booleanos são essenciais para lógica condicional. Você usa eles em condições como "se posição está aberta, então faça X". E eles são fundamentais para controlar o fluxo do código, decidindo quando executar certas ações.

Variáveis

Variáveis armazenam valores que podem mudar durante a execução. Elas são como caixas onde você guarda informações. E essas informações podem ser números, texto, ou valores verdadeiro/falso.

O poder das variáveis é que elas podem mudar. Você pode começar com preco_atual = 0; e depois atualizar para preco_atual = Fechamento; quando o preço mudar. E isso permite que seu código reaja a mudanças no mercado.

Declaração de Variáveis

Em NTSL, você declara variáveis simplesmente atribuindo um valor. Não precisa declarar o tipo explicitamente. Por exemplo, preco_atual = 0; cria uma variável numérica. quantidade = 1; cria outra variável numérica. E você pode criar quantas variáveis precisar.

Você também pode criar múltiplas variáveis de uma vez, cada uma com seu próprio valor. Por exemplo, var1 = 10;, var2 = 20;, var3 = 30;. Cada variável é independente, e você pode usar elas separadamente no código.

Nomes de Variáveis

Nomes de variáveis podem conter letras, números e underscore (_). Mas devem começar com letra. Por exemplo, preco_atual é válido, mas 1preco não é válido porque começa com número.

NTSL é case-sensitive, o que significa que preco é diferente de Preco ou PRECO. Isso é importante porque se você criar uma variável preco_atual e depois tentar usar Preco_Atual, vai dar erro. Por isso, seja consistente com maiúsculas e minúsculas.

E use nomes descritivos. preco_entrada é muito melhor que pe. Porque quando você ler o código depois, você vai entender o que cada variável faz. E se outra pessoa ler seu código, também vai entender. Nomes descritivos tornam o código mais legível e mais fácil de manter.

Operadores Aritméticos

Operações matemáticas básicas:

// Soma
resultado = 10 + 5; // 15

// Subtração
resultado = 10 - 5; // 5

// Multiplicação
resultado = 10 * 5; // 50

// Divisão
resultado = 10 / 5; // 2

// Módulo (resto da divisão)
resultado = 10 % 3; // 1

// Potência
resultado = 2 ^ 3; // 8

Operadores de Comparação

Usados em condições para comparar valores:

// Igual
se(preco == 100) { }

// Diferente
se(preco != 100) { }

// Maior que
se(preco > 100) { }

// Menor que
se(preco < 100) { }

// Maior ou igual
se(preco >= 100) { }

// Menor ou igual
se(preco <= 100) { }

Operadores Lógicos

Combinam múltiplas condições:

// E (AND) - ambas condições devem ser verdadeiras
se(preco > 100 e volume > 1000) { }

// OU (OR) - pelo menos uma condição deve ser verdadeira
se(preco > 100 ou volume > 1000) { }

// NÃO (NOT) - inverte o resultado
se(nao posicao_aberta) { }

Estruturas de Controle

Controlam o fluxo de execução do código:

Condicional: se/senao

se(condicao)
{
    // Código se condição for verdadeira
}
senao
{
    // Código se condição for falsa
}

// Exemplo
se(preco > media)
{
    Comprar(1);
}
senao
{
    Vender(1);
}

Loop: enquanto

enquanto(condicao)
{
    // Código executado enquanto condição for verdadeira
    // Cuidado com loops infinitos!
}

// Exemplo
contador = 0;
enquanto(contador < 10)
{
    Escrever("Contador: " + contador);
    contador = contador + 1;
}

Loop: para

para(i = 0; i < 10; i = i + 1)
{
    // Código executado 10 vezes
    Escrever("Iteração: " + i);
}

Funções Essenciais de Dados de Mercado

NTSL oferece funções prontas para acessar dados de mercado:

Preços

// Preço de fechamento da barra atual
fechamento = Fechamento;

// Preço de fechamento de N barras atrás
fechamento_anterior = Fechamento[1]; // 1 barra atrás
fechamento_2_barras = Fechamento[2]; // 2 barras atrás

// Outros preços
abertura = Abertura;
maxima = Maxima;
minima = Minima;

// Preço atual (último tick)
preco_atual = PrecoAtual();

Volume e Outros Dados

// Volume da barra atual
volume = Volume;

// Volume de barras anteriores
volume_anterior = Volume[1];

// Data e hora
data_atual = DataAtual();
hora_atual = HoraAtual();

Funções de Indicadores Técnicos

NTSL tem funções prontas para indicadores comuns:

Médias Móveis

// Média móvel simples
media_simples = MediaMovel(20, Fechamento);
// Parâmetros: período, série de preços

// Média móvel exponencial
media_exponencial = MediaMovelExponencial(20, Fechamento);

// Média móvel ponderada
media_ponderada = MediaMovelPonderada(20, Fechamento);

RSI (Relative Strength Index)

// RSI com período 14
rsi = RSI(14);

// RSI de barras anteriores
rsi_anterior = RSI(14)[1];

MACD

// MACD
macd = MACD(12, 26, 9);
// Parâmetros: período rápido, período lento, período sinal

// Componentes do MACD
macd_linha = MACD(12, 26, 9);
macd_sinal = MACDSinal(12, 26, 9);
macd_histograma = MACDHistograma(12, 26, 9);

Bollinger Bands

// Bandas de Bollinger
banda_superior = BollingerSuperior(20, 2);
banda_inferior = BollingerInferior(20, 2);
banda_media = BollingerMedia(20, 2);
// Parâmetros: período, desvio padrão

ATR (Average True Range)

// ATR para medir volatilidade
atr = ATR(14); // Período 14

Funções de Execução de Ordens

Funções para abrir e fechar posições:

Abrir Posições

// Comprar quantidade de contratos
Comprar(1); // Compra 1 contrato
Comprar(quantidade); // Compra quantidade definida

// Vender (short)
Vender(1); // Vende 1 contrato
Vender(quantidade); // Vende quantidade definida

Fechar Posições

// Fechar posição atual
FecharPosicao();

// Fechar todas as posições
FecharTodasPosicoes();

Verificar Posições

// Verificar se há posição aberta
se(PosicaoAberta())
{
    // Há posição aberta
}

// Obter tipo de posição
tipo = TipoPosicao(); // Retorna "COMPRA" ou "VENDA"

// Obter preço de entrada
preco_entrada = PrecoEntrada();

// Obter quantidade da posição
quantidade_posicao = QuantidadePosicao();

Funções de Cálculo e Matemática

// Valor absoluto
absoluto = Abs(-10); // 10

// Arredondar
arredondado = Round(10.7); // 11

// Arredondar para baixo
arredondado_baixo = Floor(10.7); // 10

// Arredondar para cima
arredondado_cima = Ceil(10.3); // 11

// Máximo entre dois valores
maximo = Max(10, 20); // 20

// Mínimo entre dois valores
minimo = Min(10, 20); // 10

// Potência
potencia = Pow(2, 3); // 8

// Raiz quadrada
raiz = Sqrt(16); // 4

// Logaritmo
log = Log(10);

Funções de Data e Hora

// Data atual
data = DataAtual(); // Retorna data no formato da plataforma

// Hora atual
hora = HoraAtual(); // Retorna hora no formato da plataforma

// Verificar se é dia útil
se(DiaUtil())
{
    // É dia útil
}

// Verificar horário de pregão
se(NoPregao())
{
    // Está no horário de pregão
}

Funções de Debug e Log

// Escrever mensagem no log
Escrever("Mensagem de debug");
Escrever("Preço atual: " + preco_atual);
Escrever("RSI: " + rsi);

// Alertas
Alerta("Condição importante detectada!");

Arrays e Séries Temporais

NTSL permite acessar valores históricos usando colchetes:

// Acessar valores anteriores
fechamento_atual = Fechamento; // Barra atual
fechamento_1 = Fechamento[1]; // 1 barra atrás
fechamento_2 = Fechamento[2]; // 2 barras atrás

// Funciona com qualquer série
media_anterior = MediaMovel(20, Fechamento)[1];
rsi_anterior = RSI(14)[1];

Exemplo Completo: Robô Básico

Vamos criar um exemplo completo que combina tudo:

// Parâmetros configuráveis
periodo_media = 20;
quantidade = 1;
stop_loss = 50;
take_profit = 100;

// Variáveis
media = 0;
posicao_aberta = false;

inicio()
{
    Escrever("Robô iniciado");
    Escrever("Período da média: " + periodo_media);
}

tick()
{
    // Calcular média móvel
    media = MediaMovel(periodo_media, Fechamento);
    
    // Lógica de entrada
    se(nao PosicaoAberta())
    {
        // Compra se preço cruza acima da média
        se(Fechamento > media e Fechamento[1] <= media)
        {
            Comprar(quantidade);
            Escrever("Compra executada em " + Fechamento);
            posicao_aberta = true;
        }
    }
    
    // Gerenciamento de posição
    se(PosicaoAberta())
    {
        preco_entrada = PrecoEntrada();
        preco_atual = Fechamento;
        
        // Calcular P&L
        lucro_pontos = preco_atual - preco_entrada;
        
        // Stop loss
        se(lucro_pontos <= -stop_loss)
        {
            FecharPosicao();
            Escrever("Stop loss acionado");
            posicao_aberta = false;
        }
        
        // Take profit
        se(lucro_pontos >= take_profit)
        {
            FecharPosicao();
            Escrever("Take profit acionado");
            posicao_aberta = false;
        }
    }
}

Boas Práticas

• Use nomes descritivos: preco_entrada é melhor que pe
• Comente código complexo: Explique lógica não óbvia
• Teste em simulação primeiro: Nunca use código não testado em conta real
• Use funções prontas: Não reinvente a roda - use funções do NTSL
• Valide entradas: Verifique se valores estão dentro de limites esperados

Conclusão

Este manual cobre os fundamentos essenciais do NTSL. Com este conhecimento, você consegue ler e entender robôs existentes, além de criar seus próprios.

Pratique criando robôs simples primeiro. À medida que ganha experiência, você naturalmente aprende funções mais avançadas e técnicas mais sofisticadas.

Lembre-se: programação é uma habilidade que se desenvolve com prática. Comece simples, teste muito e vá evoluindo gradualmente.

Artigos Relacionados

Ver todos os posts