{"id":1313,"date":"2026-11-17T20:06:36","date_gmt":"2026-11-17T23:06:36","guid":{"rendered":"https:\/\/www.pascalscada.com\/?page_id=1313"},"modified":"2026-11-17T20:06:36","modified_gmt":"2026-11-17T23:06:36","slug":"logging","status":"publish","type":"page","link":"https:\/\/www.pascalscada.com\/pb\/logging\/","title":{"rendered":"Log (TpSCADALogger)"},"content":{"rendered":"<h5>Introdu\u00e7\u00e3o<\/h5>\n<p><img decoding=\"async\" src=\"https:\/\/www.pascalscada.com\/wp-content\/uploads\/2026\/11\/TpSCADALogger.png\" alt=\"\" \/> <strong><code>TpSCADALogger<\/code><\/strong> re\u00fane o que acontece dentro do PascalSCADA \u2014 comunica\u00e7\u00e3o, conex\u00f5es, threads de scan, tags, eventos disparados, seguran\u00e7a, banco de dados \u2014 e manda cada mensagem para a <strong>tela<\/strong>, para um <strong>arquivo<\/strong>, para um <strong>evento<\/strong> ou para <strong>lugar nenhum<\/strong>, conforme uma lista de <strong>regras<\/strong>. Uma regra escolhe as mensagens pela <strong>fonte<\/strong> (o nome do componente), pela <strong>classe<\/strong>, pela <strong>categoria<\/strong> e pelo <strong>n\u00edvel<\/strong>. Assim voc\u00ea decide, por exemplo, que o tr\u00e1fego de uma porta Modbus vai para um arquivo s\u00f3 dela, que os avisos do driver S7 v\u00e3o para a tela e que todo erro tamb\u00e9m dispara um evento.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/www.pascalscada.com\/wp-content\/uploads\/2026\/11\/TpSCADALogMemo.png\" alt=\"\" \/> <strong><code>TpSCADALogMemo<\/code><\/strong> \u00e9 o destino de tela: um memo somente leitura que mostra as linhas que as regras mandam para a tela.<\/p>\n<p>Os dois ficam na paleta <strong>PascalSCADA Utils<\/strong>. O <code>TpSCADALogger<\/code> est\u00e1 no pacote <code>pascalscada_common<\/code> (sem LCL: funciona tamb\u00e9m em servi\u00e7os e programas de console); o <code>TpSCADALogMemo<\/code> est\u00e1 no <code>pascalscada_hmi<\/code>.<\/p>\n<h5>Como funciona<\/h5>\n<p>Todas as partes do framework publicam suas mensagens num \u00fanico hub global. Cada <code>TpSCADALogger<\/code> ativo recebe uma c\u00f3pia e a passa pelas suas regras. Pode haver v\u00e1rios loggers no mesmo programa; cada um recebe todas as mensagens.<\/p>\n<p>O log n\u00e3o custa nada enquanto ningu\u00e9m escuta: antes de montar uma mensagem (formatar um texto, converter um frame em hexadecimal) o c\u00f3digo pergunta ao hub se alguma regra ativa quer aquela categoria e n\u00edvel. Publicar s\u00f3 copia a mensagem para a fila do logger; arquivos, tela e evento s\u00e3o tratados pela thread do pr\u00f3prio logger, em lotes, e uma thread de comunica\u00e7\u00e3o nunca espera pelo disco ou pela tela. A tela e o evento chegam na <strong>thread principal<\/strong>.<\/p>\n<h5>N\u00edveis e categorias<\/h5>\n<table>\n<thead>\n<tr>\n<th>N\u00edvel<\/th>\n<th>Uso<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>llTrace<\/code><\/td>\n<td>Tudo, inclusive os bytes de cada frame. Muitos dados.<\/td>\n<\/tr>\n<tr>\n<td><code>llDebug<\/code><\/td>\n<td>Detalhes \u00fateis para entender um problema.<\/td>\n<\/tr>\n<tr>\n<td><code>llInfo<\/code><\/td>\n<td>Eventos normais: conectou, desconectou, iniciou.<\/td>\n<\/tr>\n<tr>\n<td><code>llWarning<\/code><\/td>\n<td>Algo deu errado e foi recuperado (timeout, reconex\u00e3o).<\/td>\n<\/tr>\n<tr>\n<td><code>llError<\/code><\/td>\n<td>Algo falhou.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<table>\n<thead>\n<tr>\n<th>Categoria<\/th>\n<th>Mensagens sobre<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>lcComm<\/code><\/td>\n<td>bytes enviados e recebidos por uma porta<\/td>\n<\/tr>\n<tr>\n<td><code>lcConnection<\/code><\/td>\n<td>abertura, fechamento, reconex\u00e3o, timeouts<\/td>\n<\/tr>\n<tr>\n<td><code>lcProtocol<\/code><\/td>\n<td>frames e requisi\u00e7\u00f5es de um driver de protocolo<\/td>\n<\/tr>\n<tr>\n<td><code>lcScan<\/code><\/td>\n<td>threads de scan e de atualiza\u00e7\u00e3o, filas<\/td>\n<\/tr>\n<tr>\n<td><code>lcTag<\/code><\/td>\n<td>leituras, escritas e valores de tags<\/td>\n<\/tr>\n<tr>\n<td><code>lcEvent<\/code><\/td>\n<td>eventos disparados<\/td>\n<\/tr>\n<tr>\n<td><code>lcThread<\/code><\/td>\n<td>threads iniciando e terminando<\/td>\n<\/tr>\n<tr>\n<td><code>lcSecurity<\/code><\/td>\n<td>login, logout, autoriza\u00e7\u00e3o<\/td>\n<\/tr>\n<tr>\n<td><code>lcDatabase<\/code><\/td>\n<td>a camada de banco de dados<\/td>\n<\/tr>\n<tr>\n<td><code>lcHMI<\/code><\/td>\n<td>os controles visuais<\/td>\n<\/tr>\n<tr>\n<td><code>lcUser<\/code><\/td>\n<td>mensagens da sua aplica\u00e7\u00e3o<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h5>Propriedades do TpSCADALogger<\/h5>\n<table>\n<thead>\n<tr>\n<th>Propriedade<\/th>\n<th>Descri\u00e7\u00e3o<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>Active<\/code><\/td>\n<td>Liga e desliga o logger (padr\u00e3o <code>True<\/code>). Em tempo de projeto ele nunca roda.<\/td>\n<\/tr>\n<tr>\n<td><code>Rules<\/code><\/td>\n<td>As regras de roteamento, avaliadas em ordem (veja abaixo).<\/td>\n<\/tr>\n<tr>\n<td><code>Display<\/code><\/td>\n<td>O destino de tela: um <code>TpSCADALogMemo<\/code> ou qualquer componente que implemente <code>IpSCADALogDisplay<\/code>. O Object Inspector lista s\u00f3 esses.<\/td>\n<\/tr>\n<tr>\n<td><code>LineFormat<\/code><\/td>\n<td>O formato da linha. Marcadores: <code>%time%<\/code>, <code>%date%<\/code>, <code>%level%<\/code>, <code>%category%<\/code>, <code>%thread%<\/code> (<code>main<\/code>, <code>T1<\/code>, <code>T2<\/code>\u2026 na ordem em que as threads publicam pela primeira vez), <code>%threadid%<\/code> (o id do sistema), <code>%source%<\/code>, <code>%class%<\/code>, <code>%msg%<\/code>, <code>%data%<\/code> (os bytes em hexadecimal, vazio quando n\u00e3o h\u00e1). Vazio volta ao padr\u00e3o.<\/td>\n<\/tr>\n<tr>\n<td><code>OnLog<\/code><\/td>\n<td>Evento chamado, na thread principal, para cada mensagem que uma regra manda para <code>ltEvent<\/code>. Recebe os campos da mensagem (<code>Entry<\/code>) e a linha formatada (<code>Line<\/code>).<\/td>\n<\/tr>\n<tr>\n<td><code>MaxFileSize<\/code><\/td>\n<td>Tamanho m\u00e1ximo de um arquivo de log em bytes; acima dele o arquivo \u00e9 renomeado para <code>.1<\/code>, <code>.2<\/code>\u2026 (<code>0<\/code> = sem limite).<\/td>\n<\/tr>\n<tr>\n<td><code>MaxRotatedFiles<\/code><\/td>\n<td>Quantos arquivos renomeados s\u00e3o mantidos (padr\u00e3o 5).<\/td>\n<\/tr>\n<tr>\n<td><code>FileIdleCloseMs<\/code><\/td>\n<td>Um arquivo que n\u00e3o recebe nada por esse tempo \u00e9 fechado e reaberto quando preciso (padr\u00e3o 10 s).<\/td>\n<\/tr>\n<tr>\n<td><code>FlushIntervalMs<\/code><\/td>\n<td>De quanto em quanto tempo a thread do logger grava o que est\u00e1 na fila (padr\u00e3o 200 ms).<\/td>\n<\/tr>\n<tr>\n<td><code>MaxQueue<\/code><\/td>\n<td>Mensagens que a fila comporta; acima disso as novas s\u00e3o descartadas e depois sai uma linha <em>N log messages dropped<\/em>. <code>Dropped<\/code> conta quantas.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p><code>Flush(TimeoutMs)<\/code> espera at\u00e9 que tudo o que foi publicado antes da chamada esteja gravado e, na thread principal, mostrado. <code>PSLogFlushAll<\/code> faz o mesmo para todos os loggers.<\/p>\n<p>A linha padr\u00e3o fica assim:<\/p>\n<pre><code>2026-11-17 14:03:22.417 [WARN ] [connection] T2 Form1.ModBusTCP1 (TModBusTCPDriver): timeout, reconnecting\r\n2026-11-17 14:03:22.419 [TRACE] [comm] T2 Form1.TCP_UDPPort1 (TTCP_UDPPort): TX | 00 01 00 00 00 06 01 03 00 00 00 0A\r\n<\/code><\/pre>\n<h5>Regras<\/h5>\n<p>Uma mensagem casa com uma regra quando <strong>todas<\/strong> estas condi\u00e7\u00f5es valem:<\/p>\n<table>\n<thead>\n<tr>\n<th>Propriedade<\/th>\n<th>Casa quando<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>Enabled<\/code><\/td>\n<td>a regra est\u00e1 habilitada.<\/td>\n<\/tr>\n<tr>\n<td><code>MinLevel<\/code><\/td>\n<td>o n\u00edvel da mensagem \u00e9 este ou maior (padr\u00e3o <code>llInfo<\/code>).<\/td>\n<\/tr>\n<tr>\n<td><code>Categories<\/code><\/td>\n<td>a categoria da mensagem est\u00e1 no conjunto (padr\u00e3o: todas).<\/td>\n<\/tr>\n<tr>\n<td><code>SourceMask<\/code><\/td>\n<td>a fonte casa com a m\u00e1scara. A fonte \u00e9 o caminho do componente, como <code>Form1.ModBusTCP1<\/code>. Aceita <code>*<\/code> e <code>?<\/code>, n\u00e3o diferencia mai\u00fasculas e aceita v\u00e1rias m\u00e1scaras separadas por <code>;<\/code>. Vazio significa tudo.<\/td>\n<\/tr>\n<tr>\n<td><code>ClassMask<\/code><\/td>\n<td>a classe da fonte <strong>ou um ancestral dela<\/strong> casa com a m\u00e1scara \u2014 <code>TProtocolDriver<\/code> casa com todos os drivers. Mesma sintaxe da <code>SourceMask<\/code>.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>E ent\u00e3o:<\/p>\n<table>\n<thead>\n<tr>\n<th>Propriedade<\/th>\n<th>Efeito<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>Targets<\/code><\/td>\n<td>Para onde vai: <code>ltScreen<\/code>, <code>ltFile<\/code>, <code>ltEvent<\/code>, em qualquer combina\u00e7\u00e3o. <strong>Vazio descarta a mensagem.<\/strong><\/td>\n<\/tr>\n<tr>\n<td><code>FileName<\/code><\/td>\n<td>O arquivo de <code>ltFile<\/code>. Aceita <code>%date%<\/code>, <code>%source%<\/code>, <code>%class%<\/code>, <code>%category%<\/code> e <code>%level%<\/code>, ent\u00e3o uma regra pode gravar um arquivo por dia, por fonte ou por classe. Um caminho relativo \u00e9 relativo \u00e0 <strong>pasta do execut\u00e1vel<\/strong>; pastas que faltam s\u00e3o criadas.<\/td>\n<\/tr>\n<tr>\n<td><code>StopProcessing<\/code><\/td>\n<td>Quando a regra casa, as regras seguintes n\u00e3o s\u00e3o avaliadas. Com <code>Targets<\/code> vazio vira uma <strong>exclus\u00e3o<\/strong>.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Quando v\u00e1rias regras casam, a mensagem vai para todos os destinos delas; duas regras no mesmo arquivo gravam a linha uma vez s\u00f3.<\/p>\n<p>Exemplos:<\/p>\n<table>\n<thead>\n<tr>\n<th>Objetivo<\/th>\n<th>Regra<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Erros e avisos de tudo na tela<\/td>\n<td><code>MinLevel = llWarning<\/code>, <code>Targets = [ltScreen]<\/code><\/td>\n<\/tr>\n<tr>\n<td>Tr\u00e1fego de cada porta num arquivo di\u00e1rio pr\u00f3prio<\/td>\n<td><code>Categories = [lcComm]<\/code>, <code>MinLevel = llTrace<\/code>, <code>Targets = [ltFile]<\/code>, <code>FileName = logs\/%source%-%date%.log<\/code><\/td>\n<\/tr>\n<tr>\n<td>Tudo do driver S7CommPlus num arquivo<\/td>\n<td><code>ClassMask = TS7CommPlusDriver<\/code>, <code>MinLevel = llDebug<\/code>, <code>Targets = [ltFile]<\/code>, <code>FileName = logs\/s7plus.log<\/code><\/td>\n<\/tr>\n<tr>\n<td>Ignorar um componente barulhento<\/td>\n<td>primeira regra: <code>SourceMask = Form1.Debug*<\/code>, <code>Targets = []<\/code>, <code>StopProcessing = True<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h5>TpSCADALogMemo<\/h5>\n<p>Um memo preparado para logs: somente leitura, sem quebra de linha, com barras de rolagem. Ligue-o no <code>Display<\/code> do logger.<\/p>\n<table>\n<thead>\n<tr>\n<th>Propriedade<\/th>\n<th>Descri\u00e7\u00e3o<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>MaxLines<\/code><\/td>\n<td>Linhas mantidas; as mais antigas saem primeiro (padr\u00e3o 1000, <code>0<\/code> = sem limite).<\/td>\n<\/tr>\n<tr>\n<td><code>AutoScroll<\/code><\/td>\n<td>Mant\u00e9m a \u00faltima linha vis\u00edvel quando chegam linhas novas (padr\u00e3o <code>True<\/code>). Desligue para ler com calma.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Uma fonte monoespa\u00e7ada deixa as colunas alinhadas. Para mostrar o log em outro lugar (uma lista, uma grade, uma barra de status) use o evento <code>OnLog<\/code>, ou escreva um componente que implemente <code>IpSCADALogDisplay<\/code> (um m\u00e9todo, <code>AddLogLines(Lines: TStrings)<\/code>, chamado na thread principal).<\/p>\n<h5>O que o PascalSCADA publica<\/h5>\n<table>\n<thead>\n<tr>\n<th>Quem<\/th>\n<th>Categoria \/ n\u00edvel<\/th>\n<th>Mensagens<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>toda porta de comunica\u00e7\u00e3o<\/td>\n<td><code>lcComm<\/code> \/ <code>llTrace<\/code><\/td>\n<td><code>TX 12\/12 iorOK<\/code>, <code>RX 10\/10 iorOK<\/code>, com os bytes como dados, na ordem em que a porta os fez.<\/td>\n<\/tr>\n<tr>\n<td><\/td>\n<td><code>lcComm<\/code> \/ <code>llWarning<\/code><\/td>\n<td><code>read failed: iorTimeOut<\/code>, <code>write failed: \u2026<\/code><\/td>\n<\/tr>\n<tr>\n<td><\/td>\n<td><code>lcConnection<\/code> \/ <code>llInfo<\/code><\/td>\n<td><code>port started<\/code>, <code>port stopped<\/code><\/td>\n<\/tr>\n<tr>\n<td><\/td>\n<td><code>lcConnection<\/code> \/ <code>llError<\/code><\/td>\n<td><code>open failed<\/code>, <code>close failed<\/code>, com o erro do sistema operacional<\/td>\n<\/tr>\n<tr>\n<td><\/td>\n<td><code>lcConnection<\/code> \/ <code>llWarning<\/code><\/td>\n<td><code>connection lost<\/code><\/td>\n<\/tr>\n<tr>\n<td><code>TTCP_UDPPort<\/code><\/td>\n<td><code>lcConnection<\/code> \/ <code>llInfo<\/code><\/td>\n<td><code>connected<\/code>, <code>reconnecting<\/code> (<code>llDebug<\/code>: <code>closing the socket<\/code>)<\/td>\n<\/tr>\n<tr>\n<td><code>TS7CommPlusDriver<\/code><\/td>\n<td><code>lcProtocol<\/code> \/ <code>llDebug<\/code><\/td>\n<td>as mesmas mensagens do <code>OnDebug<\/code> (inclusive as da conex\u00e3o), com o driver como fonte<\/td>\n<\/tr>\n<tr>\n<td><code>TOPCUADriver<\/code><\/td>\n<td><code>lcProtocol<\/code> \/ o n\u00edvel da mensagem<\/td>\n<td>as mesmas mensagens do <code>OnLog<\/code>; o <code>LogLevel<\/code> do driver continua decidindo o que a biblioteca informa<\/td>\n<\/tr>\n<tr>\n<td>todo driver de protocolo<\/td>\n<td><code>lcThread<\/code> \/ <code>llDebug<\/code><\/td>\n<td><code>TScanThread started<\/code>, <code>TScanUpdate finished<\/code>\u2026 (<code>llError<\/code> quando uma exce\u00e7\u00e3o para uma thread)<\/td>\n<\/tr>\n<tr>\n<td><\/td>\n<td><code>lcScan<\/code> \/ <code>llError<\/code><\/td>\n<td>uma exce\u00e7\u00e3o durante o scan (<code>scan read raised \u2026<\/code>, <code>tag update raised \u2026<\/code>) \u2014 antes elas eram engolidas em sil\u00eancio<\/td>\n<\/tr>\n<tr>\n<td>todo tag<\/td>\n<td><code>lcTag<\/code> \/ <code>llDebug<\/code><\/td>\n<td><code>scan write requested: [12.5]<\/code>, <code>scan write ok<\/code> (<code>sync<\/code> para escritas s\u00edncronas)<\/td>\n<\/tr>\n<tr>\n<td><\/td>\n<td><code>lcTag<\/code> \/ <code>llWarning<\/code><\/td>\n<td><code>scan write failed: ioTimeOut<\/code>; <code>read failed: ioCommError<\/code> <strong>uma vez<\/strong> quando a leitura passa a falhar, e <code>reading again<\/code> (<code>llInfo<\/code>) quando volta<\/td>\n<\/tr>\n<tr>\n<td><\/td>\n<td><code>lcTag<\/code> \/ <code>llTrace<\/code><\/td>\n<td>toda leitura (<code>scan read ioOk<\/code>) e toda mudan\u00e7a de valor (<code>value changed: 12.5 (raw 125)<\/code>)<\/td>\n<\/tr>\n<tr>\n<td><\/td>\n<td><code>lcEvent<\/code> \/ <code>llTrace<\/code><\/td>\n<td>cada evento atribu\u00eddo e disparado: <code>OnValueChange<\/code>, <code>OnValueChangeFirst<\/code>, <code>OnAsyncValueChange<\/code>, <code>OnReadOk<\/code>, <code>OnReadFail<\/code>, <code>OnWriteOk<\/code>, <code>OnWriteFail<\/code>, <code>OnUpdate<\/code><\/td>\n<\/tr>\n<tr>\n<td><\/td>\n<td><code>lcEvent<\/code> \/ <code>llError<\/code><\/td>\n<td>uma exce\u00e7\u00e3o levantada enquanto o tag era atualizado \u2014 normalmente no seu <code>OnValueChange<\/code>. Os outros tags do lote continuam sendo atualizados.<\/td>\n<\/tr>\n<tr>\n<td>gerenciadores de usu\u00e1rio<\/td>\n<td><code>lcSecurity<\/code> \/ <code>llInfo<\/code><\/td>\n<td><code>login: fabio (password)<\/code> ou <code>(chip card)<\/code>, <code>logout: fabio<\/code>, <code>access to \"valves\" granted to maria (password)<\/code> (<code>llDebug<\/code> quando o usu\u00e1rio logado j\u00e1 tem a permiss\u00e3o)<\/td>\n<\/tr>\n<tr>\n<td><\/td>\n<td><code>lcSecurity<\/code> \/ <code>llWarning<\/code><\/td>\n<td><code>login failed: fabio (password)<\/code>, <code>login blocked for 30000 ms after 3 failures<\/code>, <code>access to \"valves\" denied to maria<\/code>. <strong>A senha nunca vai para o log.<\/strong><\/td>\n<\/tr>\n<tr>\n<td>controles de HMI que escrevem num tag<\/td>\n<td><code>lcHMI<\/code> \/ <code>llInfo<\/code><\/td>\n<td><code>wrote 1 to Form1.Valve1 (user fabio)<\/code>, com o controle como fonte \u2014 uma trilha de auditoria das a\u00e7\u00f5es do operador (<code>THMIEdit<\/code>, <code>THMICheckBox<\/code>, <code>THMIButton<\/code>, <code>THMIRadioGroup<\/code>, <code>THMITrackBar<\/code>, <code>THMIComboBox<\/code>, <code>THMIUpDown<\/code>, <code>THMIScrollBar<\/code>)<\/td>\n<\/tr>\n<tr>\n<td><\/td>\n<td><code>lcHMI<\/code> \/ <code>llWarning<\/code><\/td>\n<td><code>write of 10 to Form1.Valve1 refused (user fabio): &lt;motivo&gt;<\/code>, ex.: fora dos limites do tag<\/td>\n<\/tr>\n<tr>\n<td><code>THMIDBConnection<\/code><\/td>\n<td><code>lcDatabase<\/code> \/ <code>llInfo<\/code><\/td>\n<td><code>connected (postgresql host\/db)<\/code>, <code>disconnected<\/code> (<code>llError<\/code> quando falha)<\/td>\n<\/tr>\n<tr>\n<td><\/td>\n<td><code>lcDatabase<\/code> \/ <code>llDebug<\/code><\/td>\n<td><code>SQL ok (12 rows): select \u2026<\/code>, <code>transaction committed (3 statements)<\/code><\/td>\n<\/tr>\n<tr>\n<td><\/td>\n<td><code>lcDatabase<\/code> \/ <code>llWarning<\/code>, <code>llError<\/code><\/td>\n<td><code>SQL refused (ReadOnly): \u2026<\/code>, <code>transaction rolled back \u2026<\/code>, <code>SQL failed: &lt;erro&gt;<\/code> seguido do SQL, <code>commit\/rollback failed<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>As mensagens de conex\u00e3o trazem a porta entre par\u00eanteses: <code>(192.168.0.10:502 TCP)<\/code>, <code>(COM1 19200 8N1)<\/code>. O <code>LogIOActions<\/code>\/<code>LogFile<\/code> das portas e o <code>OnDebug<\/code>\/<code>OnLog<\/code> dos drivers continuam funcionando como antes. As threads de um driver come\u00e7am antes de ele receber o nome (o form ajusta as propriedades depois), ent\u00e3o as mensagens de <em>started<\/em> mostram a classe, como em <code>Form1.&lt;TModBusTCPDriver&gt;<\/code>; tudo o que vem depois mostra o nome. <code>lcTag<\/code> e <code>lcEvent<\/code> em <code>llTrace<\/code> geram uma linha por tag a cada scan: restrinja essas regras com <code>SourceMask<\/code>. <code>lcDatabase<\/code> em <code>llDebug<\/code> grava o texto do SQL, valores inclusive: mantenha isso fora de arquivos que outras pessoas leem se os seus comandos levam dados sens\u00edveis.<\/p>\n<h5>Publicando do seu c\u00f3digo<\/h5>\n<pre class=\"brush: delphi; tab-size: 2; title: ; notranslate\" title=\"\">uses pscadalog;\r\n\r\nPSLog(Self, lcUser, llInfo, &#039;lote iniciado&#039;);\r\nPSLogFmt(Self, lcUser, llWarning, &#039;tanque %d acima de %f&#039;, &#x5B;TankNo, Level]);\r\n\r\n\/\/monte mensagens caras s\u00f3 quando algu\u00e9m quiser\r\nif PSLogWants(lcComm, llTrace) then\r\n  PSLog(Self, lcComm, llTrace, &#039;frame&#039;, FrameBytes);<\/pre>\n<p><code>Self<\/code> (o remetente) vira a fonte e a classe da mensagem; pode ser <code>nil<\/code>. <code>PSLog<\/code> pode ser chamado de qualquer thread.<\/p>\n<h5>Programas sem a LCL<\/h5>\n<p>Arquivos funcionam em qualquer programa. A tela e o evento <code>OnLog<\/code> chegam na thread principal por <code>TThread.Queue<\/code>, ent\u00e3o um programa de console ou servi\u00e7o precisa chamar <code>CheckSynchronize<\/code> de tempos em tempos (uma aplica\u00e7\u00e3o LCL j\u00e1 faz isso).<\/p>\n<h5>Exemplos relacionados<\/h5>\n<ul>\n<li><a href=\"https:\/\/github.com\/fluisgirardi\/pascalscada_v0\/tree\/master\/examples\/laz_pscadalogger\"><code>examples\/laz_pscadalogger<\/code><\/a> \u2014 um logger com tr\u00eas regras (tela, um arquivo por categoria e dia, um evento que conta os erros), um <code>TpSCADALogMemo<\/code>, um bot\u00e3o para publicar mensagens de qualquer n\u00edvel e categoria e uma rajada de quatro threads publicando ao mesmo tempo.<\/li>\n<\/ul>","protected":false},"excerpt":{"rendered":"<p>Introdu\u00e7\u00e3o TpSCADALogger re\u00fane o que acontece dentro do PascalSCADA \u2014 comunica\u00e7\u00e3o, conex\u00f5es, threads de scan, tags, eventos disparados, seguran\u00e7a, banco de dados \u2014 e manda cada mensagem para a tela, &#8230;<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-1313","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/www.pascalscada.com\/pb\/wp-json\/wp\/v2\/pages\/1313","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.pascalscada.com\/pb\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/www.pascalscada.com\/pb\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/www.pascalscada.com\/pb\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.pascalscada.com\/pb\/wp-json\/wp\/v2\/comments?post=1313"}],"version-history":[{"count":1,"href":"https:\/\/www.pascalscada.com\/pb\/wp-json\/wp\/v2\/pages\/1313\/revisions"}],"predecessor-version":[{"id":1315,"href":"https:\/\/www.pascalscada.com\/pb\/wp-json\/wp\/v2\/pages\/1313\/revisions\/1315"}],"wp:attachment":[{"href":"https:\/\/www.pascalscada.com\/pb\/wp-json\/wp\/v2\/media?parent=1313"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}