Desenvolvendo um sistema de Replay (Parte 57): Dissecando o serviço de testagem

Introdução

No artigo anterior Desenvolvendo um sistema de Replay (Parte 56): Adequando os Módulos, fizemos algumas mudanças, tanto no módulo do indicador de controle, quanto, e principalmente, no módulo do indicador de mouse.

Pelo motivo de lá o artigo já conter bastante informação, ficou decidido que não seria adicionada ainda mais informação. Já que isto muito provavelmente iria mais confundir você, caro leitor, do que ajudar a esclarecer e explicar como as coisas de fato iriam e estariam funcionando.

No anexo daquele mesmo artigo, você tem acesso ao indicador de mouse, e a um serviço. Assim que você coloca o serviço para funcionar o mesmo irá criar um ativo customizado e adicionar uma barra no mesmo, adicionando também o indicador de mouse e o indicador de controle. Ambos os módulos são colocados no gráfico do ativo customizado e apesar de não executarem nenhum tipo de atividade relacionada ao serviço, pode ser notado uma certa atividade de interação entre o usuário e ambos módulos.

Muito provavelmente você, e principalmente que tem menos intimidade com o MQL5, não consiga de fato imaginar como aquilo é possível de ser feito, ainda mais ao observar o código de ambos indicadores, você não consegue notar ou perceber algum tipo de atividade a fim de que os dados presentes no indicador, ou melhor dizendo, módulo de controle não sejam de fato perdidos.

Muito bem, para explicar isto em detalhes e com a devida calma. Este artigo, será voltado a explicar, como o serviço que se encontrava presente no dito artigo, de fato faz o seu trabalho. E esta explicação é de suma importância, já que o correto entendimento e compreensão da forma como o serviço, e este principalmente, trabalha, será algo primordial para compreender como o sistema de replay / simulação irá de fato trabalhar. Isto por que é mais simples criar, e explicar um código com muito menos coisas envolvidas, do que tentar entender um código, onde o trabalho é muito mais complexo.

Então apesar do código que será explicado, não ser de fato algo que utilizaremos a posterior, é importante que você o compreenda em detalhes. Já que toda a base da interação entre o módulo de controle, o módulo do mouse e o serviço, será muito melhor assimilado, se você entender este código mais simples.

Então sem mais delongas vamos ver o código fonte, do serviço que foi implementado e que foi visto no artigo anterior, a fim de conseguir entender o que pode ser visto no vídeo que está presente no final daquele mesmo artigo.

Dissecando o código do serviço

O código fonte do serviço pode ser visto logo abaixo, na íntegra:

01. //+------------------------------------------------------------------+
02. #property service
03. #property copyright "Daniel Jose"
04. #property description "Data synchronization demo service."
05. #property link "https://www.mql5.com/pt/articles/12000"
06. #property version   "1.00"
07. //+------------------------------------------------------------------+
08. #include <Market Replay\Defines.mqh>
09. //+------------------------------------------------------------------+
10. #define def_IndicatorControl   "Indicators\\Market Replay.ex5"
11. #resource "\\" + def_IndicatorControl
12. //+------------------------------------------------------------------+
13. #define def_Loop ((!_StopFlag) && (ChartSymbol(id) != ""))
14. //+------------------------------------------------------------------+
15. void OnStart()
16. {
17.    uCast_Double info;
18.    long id;
19.    int handle;
20.    short iPos, iMode;
21.    double Buff[];
22.    MqlRates Rate[1];
23.    
24.    SymbolSelect(def_SymbolReplay, false);
25.    CustomSymbolDelete(def_SymbolReplay);
26.    CustomSymbolCreate(def_SymbolReplay, StringFormat("Custom\\%s", def_SymbolReplay));
27.    CustomSymbolSetDouble(def_SymbolReplay, SYMBOL_TRADE_TICK_SIZE, 0.5);
28.    CustomSymbolSetDouble(def_SymbolReplay, SYMBOL_TRADE_TICK_VALUE, 5);
29.    Rate[0].close = 110;
30.    Rate[0].open = 100;
31.    Rate[0].high = 120;
32.    Rate[0].low = 90;
33.    Rate[0].tick_volume = 5;
34.    Rate[0].time = D'06.01.2023 09:00';
35.    CustomRatesUpdate(def_SymbolReplay, Rate, 1);
36.    SymbolSelect(def_SymbolReplay, true);
37.    id = ChartOpen(def_SymbolReplay, PERIOD_M30);   
38.    if ((handle = iCustom(ChartSymbol(id), ChartPeriod(id), "\\Indicators\\Mouse Study.ex5", id)) != INVALID_HANDLE)
39.       ChartIndicatorAdd(id, 0, handle);
40.    IndicatorRelease(handle);      
41.    if ((handle = iCustom(ChartSymbol(id), ChartPeriod(id), "::" + def_IndicatorControl, id)) != INVALID_HANDLE)
42.       ChartIndicatorAdd(id, 0, handle);
43.    IndicatorRelease(handle);   
44.    Print("Service maintaining sync state. Version Demo...");
45.    iPos = 0;
46.    iMode = SHORT_MIN;
47.    while (def_Loop)
48.    {
49.       while (def_Loop && ((handle = ChartIndicatorGet(id, 0, "Market Replay Control")) == INVALID_HANDLE)) Sleep(50);
50.       info.dValue = 0;
51.       if (CopyBuffer(handle, 0, 0, 1, Buff) == 1) info.dValue = Buff[0];
52.       IndicatorRelease(handle);
53.       if ((short)(info._16b[0]) == SHORT_MIN)
54.       {
55.          info._16b[0] = (ushort)iPos;
56.          info._16b[1] = (ushort)iMode;
57.          EventChartCustom(id, evCtrlReplayInit, 0, info.dValue, "");
58.       }else if (info._16b[1] != 0)
59.       {
60.          iPos = (short)info._16b[0];
61.          iMode = (short)info._16b[1];
62.       }
63.       Sleep(250);
64.    }
65.    ChartClose(id);
66.    SymbolSelect(def_SymbolReplay, false);
67.    CustomSymbolDelete(def_SymbolReplay);
68.    Print("Finished service...");   
69. }
70. //+------------------------------------------------------------------+

Código fonte do serviço de teste

Para que todos consigam de fato entender o que está acontecendo, mesmo aqueles com menos experiência em MQL5. Mas principalmente aqueles que não tem tanta familiaridade em programação de serviços para o MetaTrader 5. Vamos dissecar estes códigos em minúcias, começando na linha 2.

Quando você encontrar em um código MQL5, a propriedade que está sendo declarada na linha 2, deverá entender que se trata de um serviço. Caso esta mesma propriedade não estivesse ali, o código deverá ser encarado como sendo um Script. As principais diferenças entre um serviço e um Script, se dá primeiro, na existência ou não desta propriedade. Isto em termos de código. Já em termos de execução, a principal diferença é que um script sempre estará atrelado a um gráfico, enquanto um serviço independe da existência de algum gráfico aberto.

As demais linhas, entre 3 e 6, são bastante conhecidas por aqueles que tem o mínimo de conhecimento em programação MQL5. Neste caso podemos avançar sem dar muita importância a elas.

Já na linha 8, adicionamos um include, a fim de trazer um arquivo de cabeçalho para dentro deste código. Note que neste caso o arquivo de cabeçalho estará na pasta Include\Market Replay e tem como nome Defines.mqh. A pasta Include está na raiz do diretório principal MQL5, que será referenciado pelo MetaEditor no momento que a compilação for executada.

Agora uma atenção especial é necessária nas linhas 10 e 11. Tais linhas estão ali para que o indicador, ou melhor dizendo, módulo de controle se torne um recurso interno do código compilado do serviço. E o que isto quer de fato dizer ?!?! Isto significa que quando você por transportar o código já compilado, não precisará levar junto o código do módulo de controle, pois ele estará embutido como sendo um recurso do serviço. Por conta disto que no anexo do artigo anterior, você podia ver apenas dois executáveis. Apesar de existirem três arquivos sendo executados de fato no momento que o serviço entrasse em funcionamento.

Mas por que não incluímos também o indicador, ou melhor dizendo, módulo de mouse como sendo um recurso do serviço ?!?! Assim como fizemos com o módulo de controle ?!?! O motivo é simples. Permitir que o usuário possa fazer uso e ter um acesso simplificado ao módulo de mouse. Se este módulo fosse embutido no executável do serviço, um usuário teria dificuldades em acessar o módulo de mouse, a fim de poder colocar ele em um gráfico diferente do que seria de fato criado pelo serviço.

Por conta disto, precisamos fazer muitas vezes escolhas, do que, mas principalmente o por que colocar as coisas como sendo recursos internos de algum executável.

Continuando, vemos a linha 13. Nesta linha temos a declaração de uma definição, esta visa simplificar, ou melhor, padronizar algum tipo de teste que iremos fazer. É bem comum em programas complexos, termos que executar um mesmo tipo de teste em diversos pontos. O fato de criamos uma definição a fim de padronizar tais testes, além de simplificar e facilitar a manutenção do código, garante que iremos sempre executar o mesmo tipo de testagem. E isto em muitas situações é algo extremamente desejável por grande parte dos programadores, visto que você pode se esquecer de modificar um dado ponto de testagem, e quando por algum motivo o código for executar aquela testagem especifica, ela estará em desacordo com outros pontos. E isto costuma causar muita dor de cabeça e aborrecimentos.

Muito bem. Na linha 15 iniciamos de fato a parte executável do código. Note que OnStart é o mesmo ponto de entrada tanto em scripts, quanto em serviços. Isto para código em MQL5. Mas por conta da declaração da linha 2, sabemos que iremos tratar de um serviço. O MetaTrader 5, irá gerar apenas e somente uma chamada para este evento OnStart. Isto para cada vez que o código for ser executado. Então é preciso algumas manobras de forma a manter o código em funcionamento durante todo o tempo que for preciso. Mas isto somente acontecerá, no caso especifico, lá na linha 47. Mas antes precisamos fazer algumas coisas.

As coisas das quais acabei de mencionar, é a inicialização e adequação do serviço, a fim de que ele possa fazer algo útil para nós. Entre estes passos temos declaração, e inicialização de variáveis e condições a serem impostas ao MetaTrader 5, pelo nosso serviço. Isto a partir do momento em que ele for colocado em execução. Dado este fato, entre as linhas 17 e 22, declaramos as variáveis que iremos usar. E passamos a fazer a correta inicialização das regras a serem impostas ao MetaTrader 5.

Muito do que será visto a partir deste momento, pode parecer estranho. Mas são coisas aparentemente simples, que em primeira instância, poderiam ser feitas por outro tipo de aplicação, mas como queremos concentrar as coisas em um único código, vamos trabalhar desta forma.

Então na linha 24, dizemos ao MetaTrader 5, que o ativo do qual estamos nos referindo, deverá ser removido da janela de observação de mercado. Logo depois na linha 25, removemos o mesmo, da lista de ativos. Esta lista, contém todos os ativos, nos quais podemos ter algum tipo acesso. Mas a questão, que de fato nos interessa vem na linha 26. Nesta linha dizemos ao MetaTrader 5, que desejamos criar um ativo customizado, e informamos onde ele deverá ser criado. Você deve se atentar a isto, pois se você não tiver o devido cuidado, poderá sobrescrever um ativo de mercado ao fazer tal coisa, e ao tentar acessar o ativo real, irá na verdade estar acessando o ativo customizado. Mas normalmente, sempre tomamos alguns cuidados o que evita que tal tipo de coisa venha a de fato a ocorrer.

As linhas 26 e 27, são imprescindíveis, sem elas o módulo de mouse não conseguiria efetuar o correto ajuste a ponto de conseguir colocar a linha de preço na posição correta, isto conforme você movesse o mouse no gráfico.

Agora entre as linhas 29 e 34, definimos uma barra, que será a primeira barra a ser de fato vista no gráfico. Por motivos que não consigo de fato compreender, tal barra é sempre colocada em uma posição que não é de fato possível visualizar a máxima e mínima. Mas já que o intuito aqui, é apenas apresentar e ter uma barra no gráfico, a fim de que os módulos não gerem algum tipo de erro de range. Tal fato de a barra ser inteiramente ou não visível pouco nos importa.

Até este momento, de fato não temos absolutamente nada no gráfico, e se quer temos um gráfico. Então na linha 35, dizemos ao MetaTrader 5, que os valores definidos nas linhas anteriores, onde descrevemos a barra, deverá ser colocado como sendo a primeira barra do ativo que estamos criando. E na linha 36, dizemos ao MetaTrader 5, que o ativo deverá ser colocado na janela de observação de mercado. Se o código terminasse neste ponto, você poderia, manualmente abrir o ativo customizado e visualizar a barra que colocamos nele. Mas como queremos automatizar ainda mais coisas, temos a linha 37.

No exato momento, que a linha 37 for executada, o MetaTrader 5 irá abrir um gráfico com o ativo indicado e no período gráfico que estamos indicados. Apesar desta função já ter sido explicada em outros momentos, tanto que em um dado momento nesta sequência, expliquei o motivo de informar aos módulos o ID do gráfico. É sempre bom lembrar, que agora, temos um gráfico aberto, e que pelo fato de não estamos dizendo qual o template que deverá ser usado, o gráfico irá abrir usando o template default. E este entendimento é de suma importância para entender as próximas linhas.

Vamos começar fazendo o seguinte: Observe que na linha 38, tentamos gerar um handle, ou manipulador, a fim de tentar colocar o módulo de mouse, no gráfico. Preste bastante atenção a localização que está sendo indicada, e do nome do executável. Caso a tentativa de criação de tal handle, não aconteça por qualquer motivo, a linha 39 não será executada. Normalmente o motivo é que o executável não se encontra no local indicado, em breve irei explicar um pouco mais sobre isto. Mas se o handle for de fato criado, na linha 39, iremos adicionar o módulo no gráfico. Assim o indicador irá se tornar acessível, não necessariamente visível. Mas poderá ser acessado, ou visto na lista de indicadores presentes no gráfico.

Então na linha 40, dizemos ao MetaTrader 5, que o handle não é mais necessário, podendo assim a memória alocada ser devolvida ao sistema. No entanto por conta que o módulo, já se encontra no gráfico, o MetaTrader 5 não irá remover ele do gráfico. Salvo o fato de você informar ao MetaTrader 5 que deseja remover o módulo do gráfico.

Esta mesma sequência de comandos poderia ser removida, e o efeito seria o mesmo, ou seja, o módulo de mouse ser colocado no gráfico. Para tanto, bastaria que no template default, contivesse o módulo de mouse. Para conseguir fazer isto, você abriria um gráfico qualquer, adicionaria o indicador de mouse a este gráfico, e depois salvaria esta configuração como o nome de Default.tpl. Ou para ficar mais claro, você estaria criando o template default agora com o indicador de mouse dentro deste template. Fazer isto, eliminaria a necessidade de que tais comandos vistos entre as linhas 38 e 40 de fato existisse. Ao mesmo tempo permitiria que você pudesse colocar o indicador de mouse, em qualquer lugar mais adequado ao que você planeja ou deseja fazer.

Já no caso do módulo de controle, a coisa será é um pouco diferente. Isto pelo motivo de que o módulo de controle, esteja embutido no executável do serviço. O simples fato de isto está acontecendo, torna mais fácil que o serviço venha de fato a colocar tal módulo no gráfico. E isto é feito nas linhas 41 e 42. Onde na linha 41, geramos um handle para poder acessar o módulo, e na linha 42, adicionamos o módulo no gráfico. Repare que sem fazer uso da linha 42, o módulo de fato não seria colocado no gráfico, ele apenas seria carregado para a memória, mas o MetaTrader 5 não o lançaria para o gráfico que desejamos.

Já na linha 43, eliminamos o handle, ou manipulador, já que não precisamos mais dele. Assim como aconteceu na linha 40.

Até este momento, o serviço ainda está se comportando, como um programa, que irá se encerrar muito brevemente. Mas antes usamos a linha 44 para imprimir uma mensagem na caixa de mensagens, a fim de sabermos até onde já chegamos na execução. Logo depois, entre as linhas 45 e 46, inicializamos as últimas variáveis, das quais iremos de fato fazer uso. Atenção a este fato, estamos inicializando estas variáveis com valores que serão usados a fim de que o módulo de controle possa ser inicializado. Lembre-se de que ele apenas foi lançado no gráfico, mas ainda não foi inicializado, e por este motivo, não está de fato visível no gráfico.

Então finalmente na linha 47, entrando em um loop. Este será finalizado caso algumas das condições definidas lá na linha 13 aconteça, tornando assim a condição falsa, fazendo com que o loop se encerre. Então a partir deste momento, não iremos mais fazer as coisas de qualquer forma. Deste momento em diante, o serviço deixa de executar as coisas e passa a gerenciar o que já está em execução. É importante você ter esta noção e saber fazer tal diferenciação. Caso contrário, irá ficar tentando fazer coisas que não deveria de fato estar no laço, tornando tudo muito instável e problemático.

Mas agora vem uma coisa, um novo loop, e isto já na linha 49. Este loop da linha 49 é um tipo de loop perigoso. Isto se ele não for adequadamente planejado. O motivo disto, é que se não estivéssemos fazendo uso da definição da linha 13. Poderíamos ficar fardados a nunca sair deste loop. Isto por que o módulo de controle poderia não estar presente no gráfico, e o serviço ficaria aguardando que o MetaTrader 5, nos informasse o valor do manipulador, a fim de conseguir acessar o indicador, ou módulo de controle.

Mas por conta que ao remover o módulo de controle do gráfico, o mesmo faça com que o MetaTrader 5 feche o gráfico. Isto faz com que a definição da linha 13 se torne falsa, assim sendo, tanto o laço da linha 49, quanto o laço da linha 47 serão finalizados.

É justamente por conta disto, que estou explicando o funcionamento das coisas, neste sistema mais simples. Perceber e notar isto em um sistema mais elaborado, seria muito mais difícil de ser feito. Então sempre que você, deseja de fato testar algo, faça isto usando um programa mais simples. Mas que, no entanto, siga a mesma lógica de funcionamento do que realmente será projetado depois.

Então supondo, que o MetaTrader 5 reporte para nós, uma handle válido. Na linha 50, zeramos o valor que iremos definir se na linha 51, a leitura do buffer do indicador de controle for bem sucedida.

Note o seguinte: Se a leitura do buffer for mal sucedida por qualquer motivo. A variável que iremos usar estará zerada, mas se a leitura for bem sucedida, teremos os dados que se encontram no buffer do indicador de controle.

Assim que obtivemos os dados, podemos remover o manipulador. Isto é feito na linha 52. O motivo é que durante as próximas etapas, pode acontecer qualquer coisa, e não queremos ter falsos sinais, quando o laço vier a se repetir. Parece ser algo que diminuiria a performance geral do sistema, mas é melhor perder um pouco de performance, do que analisar dados que possivelmente podem ser inválidos ou lixo.

Agora atenção a uma coisa: Até o presente momento, o indicador, ou melhor dizendo, módulo de controle, não se encontra inicializado. No entanto, o buffer do mesmo, contém valores que foram colocados ali durante a primeira fase de funcionamento do indicador. Para entender isto veja os artigos anteriores desta sequência. Então você não deve, de maneira alguma, esperar que o retorno da leitura do buffer, seja valores zerados. Pois isto de fato não irá acontecer.

Por este motivo, temos dois testes condicionais. Um para no caso inicializar o módulo de controle, a ponto que ele saiba quais são os controles que ele irá e deverá mostrar. E outro teste, para que armazenemos aqui no serviço, o que está acontecendo no módulo de controle. Isto para que no momento, onde for preciso informar novamente a última condição de funcionamento do módulo, saibamos quais valores informa ao módulo.

Então na linha 53, verificamos se o módulo acaba de ser colocado no gráfico. Este tipo de coisa pode acontecer em dois momentos. O primeiro é quando estamos ainda na primeira execução do laço iniciado na linha 47. Neste caso os valores a serem informados ao módulo de controle vem das linhas 45 e 46. Já no segundo momento, é quando o MetaTrader 5, teve que repor o módulo de controle no gráfico, pelo motivo de que o tempo do gráfico foi alterado por qualquer motivo. Neste caso, os valores a serem usados serão os últimos que estavam no indicador de controle, antes que o MetaTrader 5 o recolocasse no gráfico.

Mas de qualquer forma, no final iremos executar na linha 57, o que fará com que o MetaTrader 5, gere um evento customizado no gráfico que o serviço está observando. Desta forma o indicador de controle, irá receber os novos valores, ou os antigos valores, dando a impressão de que de alguma forma mágica, nada foi perdido. Mas isto somente acontecerá por conta que no indicador, ou módulo de controle, fizemos com que um dado valor fosse colocado no buffer, indicando que o indicador deseja e precisa receber valores atualizados, vindos de uma fonte externa. Que no caso é o serviço que estará sendo executado na plataforma MetaTrader 5.

Agora, caso não seja este o conteúdo vindo do buffer do indicador. Temos um novo teste, este sendo executado na linha 58, onde verificamos se o valor é diferente de zero. Quando isto acontecer, significa que o indicador de controle estará em play ou pausado. No entanto, aqui, no serviço de demonstração, ambas as situações indicam para que o serviço absorva o que está no buffer do indicador, armazenando assim o valor para ser utilizado caso o MetaTrader 5 veja a remover e a recolocar o indicador novamente no gráfico, por conta de alteração no tempo gráfico.

Já que a execução pode acontecer muito rapidamente, e não precisamos de uma atualização extrarrápida. Fazemos uso da linha 63 a fim de consegui, um certo descanso para o serviço, tempo este em que o serviço não executará nada de importante. Esta linha também nos dá um ponto de final do laço que se iniciou na linha 47.

No demais, quando o usuário encerrar o serviço, ou o gráfico for fechado por qualquer motivo, iremos sair do laço iniciado na linha 47, e executaremos primeiramente a linha 65. Nesta linha 65, iremos fechar o gráfico, já que se o usuário encerrar o serviço, o gráfico ainda irá permanecer aberto. Então para evitar isto, falamos para o MetaTrader 5 que ele já poderá fechar o gráfico que estávamos utilizando.

Depois que o gráfico foi fechado, tentamos remover o símbolo customizado que foi criado, da janela de observação de mercado. Isto é tentado na linha 66. Caso nenhum outro gráfico esteja aberto, fazendo uso deste símbolo, iremos conseguir fazer com que o MetaTrader 5 o remova da observação de mercado. No entanto, mesmo depois de ele ter sido removido, ainda assim ele continuará sendo listado no ponto onde ele foi criado na linha 26.

Se de fato o símbolo foi removido da observação de mercado, usaremos a linha 67 a fim de remover ele agora da lista de símbolos listados no sistema. E por fim na linha 68, ocorrendo tudo bem, e todos os procedimentos tendo sido executados conforme o esperado, imprimiremos uma mensagem na caixa de mensagens do terminal. Informando que o serviço finalizou, e que já não temos o suporte dele sendo executado.

Conclusão

Este tipo de coisa que foi mostrado neste artigo, apesar de parecer algo aparentemente sem nenhum tipo de importância, ou utilidade a longo prazo. Traz na verdade muito conhecimento, útil e necessário para o que iremos de fato precisar fazer depois. Muitas das vezes, quando desenvolvemos alguma solução, ou aplicação, temos que lidar com cenários desconhecidos, ou pouco favoráveis. Então sempre que precisar projetar, programar, ou desenvolver algo cujo trabalho é muito mais complexo do que você consegue planejar inicialmente. Crie um pequeno programa, que seja simples de ser compreendido e estudado, mas que, no entanto, execute parte do trabalho que você precisa executar no longo prazo, e cuja tarefa seja extremamente complexa de ser totalmente implementada.

Se você fizer a coisa da forma correta, poderá pegar parte do pequeno programa que você criou, e usar no projeto que você de fato estava desenvolvendo. Por conta disto, decidi mostrar e criar este artigo daqui. Para que você possa entender, que um programa muitas vezes extremamente complexo, que envolve diversos níveis de conhecimento, não é criado assim do nada.

Ele é sempre criado em pequenas etapas que funcionam, e depois parte do que foi concebido é usado na solução maior. E é exatamente isto que iremos de fato fazer aqui no sistema de raplay / simulador. A maneira como este serviço que foi dissecado neste artigo funciona, nos dá exatamente o precisamos implementar no nosso sistema que está sendo construído.

Note que sem fazer as devidas analises, e estudos que este artigo daqui permitiu fazer. Seria pouco provável que viéssemos a ter sucesso, com um mínimo de esforço, para que os módulos funcionassem adequadamente no replay / simulador. Visto que teríamos de fazer diversos ajustes e mudanças no código, mas todas estas mudanças estarão concentradas em um único ponto, que é a classe C_Replay. Mas sem saber, onde, como e de que forma adequar a classe C_Replay, iriamos acabar por entrar em um beco, que tornaria a implementação do que foi visto aqui, algo extremamente complexo.

Mas agora sabendo como de fato o sistema irá se comportar, tudo que precisamos fazer, é criar algumas poucas modificações ( assim espero ), na classe C_Replay, a fim de que o loop presente entre as linhas 47 e 64 possa fazer parte do código do nosso sistema. Com um pequeno detalhe, diferente do que estamos vendo aqui, lá no replay / simulador, iremos fazer um cálculo a fim de acompanhar o que já foi plotado no gráfico. Mas isto será visto nos próximos artigos. Então estude com calma o que foi visto neste artigo. Entenda e aprenda como este sistema está funcionando, para assim conseguir compreender o que será visto nos próximos artigos. Pois agora vamos fazer o serviço de replay / simulador, usar estes mesmos módulos que estão funcionando, conforme você pode observar vendo o vídeo presente no artigo anterior.