# Execuções e comentários

> O painel de uma unidade: preparar um procedimento e os metadados dele, o Iniciar e o que ele valida, Pausar, Retomar, Parar e Abortar, os cartões ao vivo, os comentários, os comandos únicos, o arquivo da execução, e os caminhos da automação e do agente.

O **painel** de uma unidade (Process > Modelos > um modelo > Operação > a unidade > um painel, e o
mesmo painel na página View quando ele está marcado com Mostrar em View) é onde uma execução é
preparada, iniciada, conduzida e acompanhada. Quais cartões ele desenha, e em que ordem, é arranjado
uma vez no modelo, sob Visualização > [Painéis](process-panels); toda unidade do modelo então opera
pela mesma superfície. Acompanhar precisa apenas da árvore. Todo comando do painel exige **Executar
procedimentos**; sem essa permissão, o painel abre com o aviso "Você pode acompanhar o estado da
execução desta unidade aqui, mas iniciá-la ou conduzi-la precisa da permissão 'Executar
procedimentos'." e não desenha botão de ciclo de vida nenhum.

Um cartão para o qual a estação não dá nada a mostrar é deixado de fora em vez de desenhado vazio: o
cartão Comandos únicos precisa de um datalog ou de uma receita instantânea no modelo, o cartão
Canais precisa de um canal legível, o cartão Metadados precisa de um procedimento preparado que
pergunte um campo (ou de nada preparado ainda), e um dashboard embutido precisa de algo colocado
nele. Um painel que não arranja cartão nenhum diz "Este painel não desenha nenhum cartão. Escolha os
cartões dele na linha Painéis do modelo, em Visualização."

## O aviso de intertravamento {#the-interlock-banner}

Quando o modelo observa uma parada externa ([Automação](process-automation)), o intertravamento da
unidade fica acima de todo cartão e não desenha nada enquanto está em Sem disparo. Fora isso, ele é
um aviso intitulado **Intertravamento disparado** (alto), **Intertravamento aguardando rearme** ou
**Intertravamento indisponível**, com o motivo, o nome da origem, o valor dela e a qualidade dela.
Enquanto ele não está em Sem disparo, nenhum Iniciar, Retomar, amostra, avaliação ou aplicação de
receita novo é admitido na unidade. Um disparo encerra a execução em andamento pelo caminho comum de
término, como **Abortada** com veredito **NOK** e o motivo do término **Intertravamento**, e ninguém
é nomeado como tendo a encerrado. A trava sobrevive a um reinício. **Rearmar** aparece apenas em
Aguardando rearme, exige Executar procedimentos, uma origem que leia boa e segura e uma unidade que
execução nenhuma detenha; ele libera a trava, vai para o diário com o nome do operador, e nunca
reinicia a execução abortada.

## O cartão Execução {#the-run-card}

O cabeçalho do cartão carrega uma lâmpada que diz o que a unidade está fazendo, com as mesmas
palavras e a mesma cor da pílula na página da unidade. Aguardar os setpoints passa na frente de
qualquer outra leitura.

| Lâmpada | Cor | Quando |
| --- | --- | --- |
| **Não está gravando** | Cinza | Nenhuma execução detém a unidade. |
| **Preparando** | Cinza | O Iniciar reservou a unidade e a execução ainda não existe. |
| **Gravando** | Verde | A execução está amostrando. |
| **Aguardando os setpoints chegarem ao equipamento** | Cautela | A receita entregou os setpoints de um segmento e espera o equipamento aceitá-los; o tempo do próprio segmento ainda não começou a contar, e o datalog segue gravando. Só um segmento configurado para aguardar mostra isto ([Receitas](process-recipes#what-a-run-does-with-it)). |
| **Pausada** | Cautela | O Pausar congelou a janela temporizada no último setpoint; o datalog continua gravando. |
| **Salvando** | Cinza | A amostragem parou e o snapshot da execução está sendo escrito. |
| **Finalizando** | Cinza | A execução chegou ao estado final e está fechando o arquivo dela; a unidade ainda não está livre. |

| Campo | O que é | Valores / padrão | Efeito |
| --- | --- | --- | --- |
| Procedimento | O procedimento preparado para o próximo Iniciar. | "(nenhum)" mais todo procedimento do modelo, em ordem alfabética; nada preparado por padrão, e a preparação zera quando a aplicação inicia. | A preparação vale para a estação inteira: toda tela desta unidade, o ponto `Next.Procedure` e o cartão da Operação mostram a mesma escolha. Preparar um procedimento que fixa um conjunto de apelidos aplica aquele conjunto à unidade já na preparação, não no Iniciar; uma fixação que não pode ser aplicada deixa a preparação anterior no lugar e diz por quê no cartão. O seletor fica cinza sem Executar procedimentos e enquanto o runtime está parado. |

Os botões de ciclo de vida, na ordem em que são desenhados. Pausar e Retomar ficam de fora quando o
procedimento preparado é Controlado ou Instantâneo, porque só uma execução Temporizada tem uma
janela para congelar; sem nada preparado, os cinco são desenhados.

| Comando | O que faz | Fica cinza quando (situação) | Não é desenhado quando (papel) |
| --- | --- | --- | --- |
| Iniciar | Inicia o procedimento preparado nesta unidade. | A unidade está ocupada, nenhum procedimento está preparado, o runtime está parado, o intertravamento não está em Sem disparo, ou a estação está recusando escritas. | Sem Executar procedimentos. |
| Pausar | Congela a janela temporizada no último setpoint; o datalog continua gravando. | Nenhuma execução está Executando, ou o procedimento em execução não é Temporizado. | Sem Executar procedimentos; o procedimento preparado é Controlado ou Instantâneo. |
| Retomar | Solta a pausa e leva a janela adiante. | Nenhuma execução está Pausada, ou o intertravamento não está em Sem disparo. | Sem Executar procedimentos; o procedimento preparado é Controlado ou Instantâneo. |
| Parar | Encerra a execução limpa e a congela como histórico, a partir de Executando ou de Pausada. | Nenhuma execução detém a unidade. | Sem Executar procedimentos. |
| Abortar | Encerra a execução como abortada; o bloco de finalização ainda roda. | Nenhuma execução está Executando nem Pausada. | Sem Executar procedimentos. |

Um comando recusado escreve o motivo dele no cartão ("Nenhum procedimento está preparado. Escolha um
primeiro."), e duas frases fixas sob os botões dizem por que a estação ou a unidade não está
aceitando comandos: "Runtime parado" e o motivo do intertravamento.

## O Iniciar, e o que ele valida {#start-and-what-it-validates}

O Iniciar consome a preparação da unidade e recusa tudo antes de tomar qualquer recurso. Em ordem: a
unidade é reservada (um segundo Iniciar na mesma unidade é recusado); o procedimento preparado ainda
precisa existir ("O procedimento preparado não existe mais. Escolha um de novo.") e a preparação não
pode ter se mexido enquanto o Iniciar esperava uma edição de engenharia terminar ("O procedimento
preparado ou os metadados mudaram enquanto o início esperava. Revise a execução preparada e tente
de novo."); o procedimento precisa passar na barreira que a página dele mostra ("Não há o que
executar: este procedimento não referencia nem datalog nem receita.", "O modo temporizado precisa de
uma duração. Defina uma.", "O modo instantâneo precisa de uma receita instantânea (ou de nenhuma).
Um perfil temporizado não tem um instante único.", "O perfil da receita (*N* ms) é mais longo que a
janela temporizada (*M* ms).", e as checagens de saída de produção); toda ocorrência armada precisa
ter uma condição válida; pelo menos um canal de datalog precisa resolver para uma origem vinculada
nesta unidade ("Nenhum canal de datalog resolve para uma origem vinculada na unidade 'X'."); os
metadados perguntados precisam estar completos e tipados ("O campo de metadados 'X' é obrigatório.",
"O campo de metadados 'X' precisa ser numérico.") e todo campo sequencial precisa conseguir compor
(um código de unidade ou de procedimento faltando recusa o Iniciar); o intertravamento precisa estar
em Sem disparo; e toda origem que a receita escreve precisa estar livre (uma origem detida pela
execução de outra unidade recusa o Iniciar pelo canal e pela unidade que a detém). Só então os
contadores sequenciais são reservados, o arquivo da execução é criado com os metadados já escritos
nele, e os motores são lançados; as etiquetas de Início e os relatórios de Início que o procedimento
emite saem enquanto a execução se materializa ([Emitir etiquetas e
relatórios](process-emission)).

## O cartão Metadados {#the-metadata-card}

O cartão é encabeçado por "Sob o que a próxima execução de 'Procedimento' é gravada. Um campo
marcado com * é perguntado por todo procedimento." e desenha uma entrada por campo de metadados que
o procedimento preparado pergunta, na ordem do procedimento; sem nada preparado, ele diz "Prepare um
procedimento e os campos que ele pede aparecem aqui."

| Tipo de campo | O que o cartão desenha | Efeito |
| --- | --- | --- |
| Texto | Uma caixa de entrada. | Escrito na preparação da estação inteira enquanto você digita; o Iniciar o grava no arquivo da execução. Um campo obrigatório (marcado com *) recusa um Iniciar vazio. |
| Número | Uma caixa de entrada. | O mesmo, e o Iniciar recusa um valor que não seja número. |
| Sequencial | Uma prévia somente leitura do identificador que o contador comporia agora, ou "Reservado no início" quando ainda não existe estado de contador. | Nada é reservado por olhar: o valor definitivo é reservado no Iniciar, então um contador compartilhado por várias unidades pode andar antes disso. |

A preparação é consumida pelo Iniciar, não limpa: as entradas ficam como padrão para a próxima
execução do mesmo procedimento. Entradas digitadas para outro procedimento ficam na área de
preparação, mas inertes, já que o Iniciar lê apenas os campos do procedimento preparado. As caixas
ficam cinzas sem Executar procedimentos e enquanto o runtime está parado.

## O cartão Estado da execução {#the-run-state-card}

Três leituras: **Estado** (Executando, Pausada, Salvando, Concluída, Abortada, Falhou, ou
"Preparando" enquanto a unidade está reservada e "Ociosa" quando nada a detém), **Ciclo** ("2 / 10"
numa execução cíclica, "Sem ciclos" fora disso; deixado inteiramente de fora quando o procedimento
preparado é Controlado ou Instantâneo) e **Veredito** (o veredito ao vivo da avaliação, mantido
legível depois de a execução terminar, até a próxima começar; "Nenhum" quando nada foi julgado).
Enquanto nenhuma execução detém a unidade, o veredito que continua à vista é o da última execução, e
a leitura passa a se chamar **Veredito da última execução**, para nunca ser lido como o da execução
que vai começar.

## O que cada término faz {#what-each-end-does}

| Término | Gravação | Receita | Veredito e estado |
| --- | --- | --- | --- |
| Parar | A amostragem para depois de o bloco de finalização rodar, então a transição para o estado seguro fica no datalog. | Os setpoints de finalização são escritos. | A avaliação fecha as janelas abertas dela e dobra: OK, NOK, Indeterminada, ou Nenhum sem avaliação. Concluída. |
| Abortar | O mesmo. | Os setpoints de finalização são escritos. | NOK, seja lá o que tenha sido julgado. Abortada. |
| A janela termina (Temporizada) ou a linha é gravada (Instantânea) | O mesmo. | Os setpoints de finalização são escritos. | Como em Parar. Concluída; ninguém é nomeado como tendo a encerrado. |
| Uma escrita de receita falha com a política de falha Abortar | O mesmo. | A finalização ainda roda. | NOK. Abortada. |
| O intertravamento dispara | O mesmo. | A finalização ainda roda. | NOK. Abortada, motivo do término Intertravamento. |
| O runtime para | Toda execução ainda não selada é abortada. | A finalização ainda roda. | NOK. Abortada. |
| Um erro irrecuperável | A amostragem para; sem finalização. | Nada mais é escrito. | Nenhum. Falhou. |

Fechar a aplicação não encerra nada: uma execução no estado Executando ou Pausada é retomada na
inicialização seguinte, com um perfil temporizado pausado no segmento e no ciclo persistidos dele, e
o datalog segue no mesmo arquivo.

## O cartão Canais {#the-channels-card}

Os canais legíveis da unidade num gráfico ao vivo, cada série rotulada pelo nome em vigor nesta
unidade (um apelido aparece ao vivo) e desenhada na cor e na faixa que o modelo declara no canal,
com a barra de ferramentas que todo gráfico carrega ([Gráficos](view-charts)). Ele mostra os valores
ao vivo grave uma execução ou não. Uma frase sob o desenho só aparece quando um teto de retenção
cortou o histórico que o gráfico guarda (o que um canal pode guardar, o que um gráfico pode guardar
somando os canais dele, ou o que a estação guarda somando todo gráfico ao vivo), e ela diz o que esse
teto deixou; um gráfico que recebeu todo o histórico que pediu não carrega frase nenhuma. Os tetos
estão em [Gráfico de linhas](component-line-chart#history).

## O cartão Comentários {#the-comments-card}

O cartão é encabeçado por "Comentários · Procedimento · Unidade" enquanto uma execução está ativa e
por "Comentários · sem execução ativa" fora disso; uma unidade ociosa não mostra linha do tempo,
e uma execução terminada tira as notas dela dos [Históricos](histories-notes). Cada linha gravada
mostra a hora dela, a fase dela (Execução ou Pós-execução) e o texto dela, com dois gestos:
**Editar** a reescreve ali mesmo (Enter salva, Esc cancela; um texto em branco ou inalterado não
mexe no registro, e uma reescrita carimba o instante da edição), e **Excluir** exige dois
acionamentos, o primeiro armando a linha ("Excluir este comentário? Isso não pode ser desfeito.") e
o segundo a removendo. A caixa no pé ("Acrescente um comentário…") e **Adicionar** gravam uma
linha nova carimbada com o instante e com o operador autenticado nesta tela (a estação quando não há
ninguém). Os três gestos exigem Executar procedimentos e uma execução ativa. O mesmo acréscimo está
disponível para dashboards e agentes pelo ponto `Commands.Comment` da unidade
([O espaço de endereços da unidade](process-addresses)).

## O cartão Ocorrências {#the-occurrences-card}

Os episódios de ocorrência desta unidade, os ativos primeiro, cada um com a situação dele, os dois
relógios dele (tempo ativo e perda de sinal) e a mensagem congelada com ele; o cabeçalho conta os
episódios ativos. O que é um episódio, e como os relógios dele são derivados, está em
[Ocorrências](process-occurrences).

## O cartão Produtividade {#the-productivity-card}

A atividade de produção da unidade em **Hoje** ou na janela móvel (um controle segmentado no
cabeçalho): produtividade, rendimento e tempo decorrido típico, o livro de saídas, os desfechos de
conclusão e uma tabela por procedimento. O que conta e como é calculado é
[Produtividade](process-productivity).

## O cartão Comandos únicos {#the-single-commands-card}

Um comando isolado na unidade, fora de qualquer procedimento. Uma linha aparece apenas onde o modelo
declara aquilo de que ela dispara.

| Linha | Controles | O que ela faz | Fica cinza quando |
| --- | --- | --- | --- |
| Snapshot | Um seletor de datalog e **Capturar** | Grava uma linha de datalog agora, como uma execução Instantânea terminada nos Históricos, chamada "Snapshot · datalog". | A unidade está ocupada, o intertravamento não está em Sem disparo, o runtime está parado, um comando único ainda está correndo, ou sem Executar procedimentos. |
| Avaliar agora | Um seletor de datalog, um seletor de avaliação e **Avaliar** | Grava uma linha e a julga contra a avaliação agora; a execução se chama "Evaluate · avaliação" e carrega o veredito do momento. Desenhada apenas quando o modelo tem um datalog e uma avaliação. | O mesmo. |
| Aplicar receita | Um seletor das receitas instantâneas do modelo e **Aplicar** | Escreve os setpoints da receita uma vez, pelo funil de escrita e sob uma trava de vida curta; nenhuma execução é gravada, e o diário é o registro. Uma origem detida por uma execução viva a recusa. | O intertravamento não está em Sem disparo, o runtime está parado, uma aplicação ainda está correndo, ou sem Executar procedimentos. Ela continua disponível enquanto a unidade grava. |

Amostras e avaliações não perguntam metadados, não reservam contador e nunca contam para a produção.
Os desfechos caem no feed de ações ("Snapshot registrado. Veja em Históricos.", "Avaliada. O veredito
está registrado em Históricos.", "Receita aplicada.").

## Dashboards como cartões {#dashboards-as-cards}

Um painel pode embutir qualquer dashboard do modelo como cartão, na altura escolhida no painel. O
cartão roda a definição do modelo resolvida para esta unidade, exatamente como o nó de dashboard da
própria unidade faz, e os componentes de comando dele precisam apenas de Executar procedimentos.

## O datalog {#the-datalog}

Enquanto uma execução grava, o [datalog](process-datalogs) nomeado pelo procedimento dela escreve
uma amostra no nível da aplicação por intervalo: todo canal gravado, na ordem declarada das colunas,
cada valor emparelhado com uma marca Good ou Unavailable. A linha promete observação coerente da
aplicação, não aquisição física simultânea: os dispositivos de origem atualizam nas taxas deles. Uma
origem indisponível ou um valor que não converte é guardado como uma lacuna; um `NaN` ou uma sentinela
de engenharia recebida corretamente continua Good. Um intervalo menor não chega até lá pela tela: o
campo Intervalo de amostragem do datalog recusa um valor abaixo de 50 ms ("Digite um número de no
mínimo 50.") e devolve a caixa ao intervalo em vigor. Um intervalo que chegue a uma execução por
qualquer outro caminho é usado como está até 50 ms, e qualquer coisa menor é tratada como 50 ms.

## O arquivo da execução {#the-run-file}

O arquivo da execução é o registro completo: identidades e nomes estáveis de modelo, unidade e
procedimento, a revisão do modelo, o layout congelado de canais com a tinta de gráfico resolvida de
cada coluna, os valores de metadados, as escritas de receita como executadas, os resultados de
critério, os eventos de ocorrência, os comentários, as anotações de gráfico, os registros de
produção, os artefatos de etiqueta e os registros de relatório. O contexto congelado é capturado no
Iniciar e nunca sofre mutação; o finalizador apenas acrescenta o desfecho: veredito, estado
terminal, hora de término, quem encerrou a execução e, quando um intertravamento a encerrou, o
motivo do término. Excluir o modelo, a unidade ou o procedimento nunca toca uma execução gravada.
Navegar, exportar e regenerar documentos a partir de arquivos de execução é
[Históricos](histories).

## O caminho da automação {#the-automation-path}

Uma unidade cuja [automação](process-automation) está habilitada toma o mesmo ciclo de vida a partir
do campo: uma borda de subida na origem booleana vinculada a Iniciar, Pausar, Retomar, Parar ou
Abortar dispara aquele comando. Abortar vence Parar na mesma leitura, e qualquer outro par de bordas
simultâneas é recusado como conflitante. Um Iniciar automático resolve o procedimento dele a partir
da escolha fixa ou do seletor numérico e os metadados dele a partir das origens configuradas, sem
tocar a preparação do operador, e é admitido apenas quando a unidade está pronta para Iniciar. O
resultado é escrito de volta no retorno mapeado como CommandResult: 0 Idle, 1 Accepted, 2
UnitNotReady, 3 InvalidSelection, 4 InvalidMetadata, 5 IncompatibleCommand, 6 ConflictingCommands, 7
InternalFailure. Uma execução que a automação admitiu aparece nos Históricos com o distintivo
**Automação**, grava a automação como responsável, e a nomeia como quem a encerrou depois de um
Parar ou um Abortar automático.

## Agentes e dashboards {#agents-and-dashboards}

O servidor de agente embutido conduz o mesmo ciclo de vida pelas ferramentas de operação do Process
dele (iniciar, parar, pausar, retomar, abortar, comentar, amostrar, avaliar, aplicar receita),
registradas em diário como Agente e gravadas como Agente na execução
([Acesso de agente](agent)). Um dashboard o alcança pelos pontos de comando da unidade: um Botão em
`Commands.Start` se desabilita enquanto a prontidão lê falso e um Input em `Next.<Field>` prepara um
valor ([O espaço de endereços da unidade](process-addresses)); o procedimento em si é preparado no
[cartão Execução](#the-run-card).

## O que esta superfície não faz {#what-this-surface-does-not-do}

Ela não configura nada: canais, vínculos, metadados, o intertravamento e a automação são editados
sob a [Definição](process-definition); o que uma execução aplica, grava e julga é composto sob a
[Preparação](process-setup). Ela não edita uma execução terminada: notas pós-execução, anotações,
exportações, relatórios e etiquetas de uma execução gravada são os [Históricos](histories). E ela
nunca desenha um cartão que a estação não consegue preencher.