# Painéis de unidade na View

> A pilha de cartões pela qual uma unidade do Process é operada, como ela aparece na página View: como ela chega ali, o que cada cartão mostra e deixa você fazer, e as permissões do Process que ela obedece.

Um **painel de unidade** é uma superfície do Process de pé na página [View](home): os
cartões que um modelo arranjou para operar as unidades dele, desenhados para uma unidade.
Ele não é um dashboard. Nada nele é composto numa grade, nenhum editor abre sobre ele, e
toda unidade do modelo é operada pelos mesmos cartões, então uma bancada de quatro estações
iguais é arranjada uma vez só. O arranjo é feito na linha **Painéis** do modelo, no ambiente
do Process ([Painéis](process-panels)); esta página cobre o painel como a View o mostra.

## Como um painel chega à View {#how-a-panel-gets-onto-view}

Cada painel de um modelo carrega uma chave **Mostrar em View** na barra da linha dele, no
ambiente do Process (ela exige a permissão **Gerenciar o Process**). Ligada, o painel coloca
uma entrada por unidade do modelo na coluna Visualização, chamada `Modelo · Unidade · Painel`
e com o ícone escolhido no painel, ou com a marca fixa de um painel quando nenhum foi
escolhido. As entradas ficam sob o cabeçalho **Painéis da unidade**, depois das suas pastas
e telas, até você arquivar uma numa pasta pelo menu da linha dela, exatamente como uma tela
sua; um modelo sem nenhuma unidade não coloca nada ali. Uma **tela** de modelo mostrada na
View do mesmo jeito é outra coisa: ela roda no canvas, resolvida para a unidade dela, e está
coberta no fim desta página.

A barra do palco nomeia a entrada com o nome inteiro dela e oferece **Editar no Process**
para um papel que pode gerenciar modelos, o que abre a linha do próprio painel na página do
Process. **Copiar** e **Editar** não são desenhados: não há layout a tomar. **Expandir** e
**Tela cheia** funcionam como em qualquer tela, e a barra de status continua ligada.

## Permissões {#permissions}

Ver um painel de unidade exige **Ver modelos**; a lista de visibilidade dos seus dashboards
não se aplica. Tudo o que comanda a unidade exige **Executar procedimentos**, e um papel sem
essa permissão lê o aviso no topo da pilha: "Você pode acompanhar aqui o estado de execução
desta unidade, mas iniciá-la ou conduzi-la exige a permissão “Executar procedimentos”." O cartão de execução então não desenha nem a escolha do procedimento nem
os botões de ciclo de vida, o cartão de comandos avulsos não é desenhado de jeito nenhum, as
entradas de metadados ficam desabilitadas, e um componente de comando dentro de um cartão
ganha a marca de trava com "É preciso a permissão Executar procedimentos." na dica
dele. A permissão **Operar dashboards** não tem papel nenhum aqui.

Duas outras recusas vêm da estação, e não do papel, e as duas são ditas no cartão que
disparou o comando: por que a estação como um todo não está aceitando operações de execução
(o runtime parado: "Runtime parado"), e por que esta unidade em particular não está (uma
barreira de execução, como um intertravamento disparado). Quem pressionou é registrado a
cada toque: o usuário autenticado nesta conexão, ou a estação quando não há ninguém.

## A pilha {#the-stack}

A entrada abre como uma coluna de cartões com rolagem, na ordem em que o painel os arranja.
Todo cartão abre com o mesmo topo: o nome dele à esquerda e, à direita, a única coisa que o
qualifica neste momento. Um cartão a que a estação não dá nada a mostrar é deixado de fora,
em vez de ficar de pé vazio: comandos avulsos sem datalog e sem receita instantânea a
disparar, canais num modelo sem canal legível, metadados enquanto o procedimento preparado
não pede campo nenhum, um cartão de tela cuja tela sumiu ou ainda está vazia. Um painel que
não desenha 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."

Acima dos cartões, e nunca arranjado para fora, fica o **aviso de intertravamento** quando o
intertravamento de parada do modelo está habilitado: nada enquanto a unidade está normal; um
aviso crítico enquanto ele está **Disparado**, com o motivo, a origem, o valor e a qualidade
dela; um aviso de atenção enquanto ele está **Aguardando rearme**, com um botão **Rearmar**
desenhado só para um papel com Executar procedimentos. O que o intertravamento é e como ele é configurado está em
[Automação](process-automation).

### Execução {#run}

O procedimento preparado para a próxima partida e os comandos que conduzem a execução.

| Elemento | O que ele mostra ou faz |
|---|---|
| Topo, lado direito | Uma lâmpada e uma palavra: **Gravando** enquanto uma execução grava, **Preparando** enquanto a unidade está reservada mas ainda não grava, **Não está gravando** no resto do tempo. |
| Procedimento | Um seletor com "(nenhum)" e todo procedimento do modelo. Escolher um o prepara para o próximo Iniciar; "(nenhum)" não prepara nada. Desabilitado sem Executar procedimentos ou enquanto o runtime está parado. Uma preparação que a estação recusa (um conjunto de apelidos que não pode ser fixado, por exemplo) faz o seletor voltar e diz o motivo no cartão. |
| Iniciar, Pausar, Retomar, Parar, Abortar | Os comandos de ciclo de vida, cada um esmaecido até a execução poder recebê-lo, com uma dica dizendo o que ele faz: "Iniciar o procedimento preparado nesta unidade", "Congelar a janela temporizada; o datalog continua gravando", "Soltar a pausa e seguir com a janela", "Encerrar a execução por bem e congelá-la como histórico", "Encerrar a execução como abortada; o bloco de finalização ainda roda". Pausar e Retomar são desenhados só enquanto o procedimento preparado é Temporizado, porque só uma janela temporizada pode ser congelada; sem nada preparado o conjunto inteiro é desenhado. |
| Notas sob os comandos | O último comando que esta unidade recusou, e depois os motivos da estação inteira e os da própria unidade para não aceitar operações de execução, enquanto eles valerem. |

O que o Iniciar valida e o que cada comando faz com a execução estão em
[Execuções e comentários](process-runs).

### Metadados {#metadata}

Uma entrada por campo de metadado que o procedimento preparado pede, sob a linha "Sob o que
a próxima execução de “Procedimento” é registrada. Um campo marcado com * é pedido por todo
procedimento." Um campo manual é uma entrada de texto, desabilitada sem Executar
procedimentos; um campo sequencial nunca é uma entrada e sim uma previsão do identificador
que o contador vai reservar no Iniciar (ou "Reservado no início" enquanto não dá para
prever), com uma dica dizendo que um contador compartilhado pode andar até lá. Sem nada
preparado o cartão diz "Prepare um procedimento e os campos que ele pede aparecem aqui." O
que você digita é preparação da estação inteira: outra conexão vê na hora.

### Estado da execução {#run-state}

Três leituras: **Estado** (o estado da execução, ou "Preparando" enquanto a unidade está
reservada, "Ociosa" no resto do tempo), **Ciclo** ("2 / 10", ou "Sem ciclos"), desenhado só
enquanto o procedimento preparado é Temporizado, já que só uma janela temporizada se repete, e
**Veredito** (o veredito das evidências até aqui, "Nenhum" quando não há). 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. Nada aqui é tingido.

### Comentários {#comments}

A linha do tempo de comentários da execução ativa da unidade, encabeçada pela linha que a
própria linha do tempo escreve sobre si (qual execução, ou que não há nenhuma). Cada
comentário mostra a hora dele, a fase e o texto, com **Editar** (reescrever no lugar; Enter
salva, Escape cancela) e **Excluir** (o primeiro toque arma a linha com "Excluir este
comentário? Isso não pode ser desfeito." e o segundo a remove). A caixa **Acrescente um
comentário…** e o botão **Adicionar** dela juntam um comentário à execução ativa. Tudo
isso exige Executar procedimentos; uma linha do tempo travada continua legível e diz o
motivo no gesto. O comando responde na linha de feedback própria dele, sob a caixa.

### Ocorrências {#occurrences}

Os episódios de ocorrência ativos e recentes da unidade, encabeçados pela linha da própria
lista. Cada linha traz o nome da ocorrência, o estado dela, há quanto tempo ela está
**Ativa**, um relógio de **Perda de sinal** ou **Sinal indisponível** onde a origem caiu, e
a mensagem dela. Uma lista vazia diz isso. Os episódios vêm das
[Ocorrências](process-occurrences) do modelo.

### Canais {#channels}

Os canais legíveis da unidade num gráfico ao vivo só, cada série com o nome que o canal tem
nesta unidade (um apelido aparece ao vivo) e desenhada na cor e sobre as faixas que o canal
declara em [Canais](process-channels). O gráfico carrega a fileira padrão de botões com que
um gráfico numa tela abre (ampliar uma área, restaurar o zoom, salvar e copiar um PNG,
mostrar ou esconder séries, a dica de valor e a tela cheia) e uma nota sob o desenho quando a
retenção que ele pediu não pôde ser concedida inteira; o que cada botão faz está em
[Gráficos](view-charts).

### Produtividade {#productivity}

As quantidades produzidas, as taxas e o registro de desfechos da unidade, sob a linha
"Atividade de produção hoje." ou "Atividade de produção em N horas." (ou dias). O
lado direito do topo é o período: **Hoje** (desde a meia-noite local) ou **Últimas N h** /
**Últimos N d**, a janela deslizante que o modelo declara (ou que a unidade sobrepõe) em
[Produtividade](process-productivity). O corpo são três leituras (**Produtividade**,
**Rendimento**, **Tempo decorrido típico**, cada uma dizendo o que ainda lhe falta em vez de desenhar
um texto de exemplo: "Sem referência", "Não classificado", "Não medido"), o **Registro de
saídas** (uma linha por saída: nome, quantidade com a unidade dela, e a taxa por hora
decorrida ou "Sem tempo decorrido"), a contagem de **Resultados de conclusão** (Finalizadas,
OK, NOK, Inconclusivas, Não avaliadas, Abortadas, Falharam) e um detalhamento **Por
procedimento** com os mesmos números por procedimento. Um modelo em que nenhum procedimento
contribui com produção diz: "Nenhum procedimento contribui com produção ainda. Habilite “Produção”
em um procedimento para acender estes indicadores."; um período sem nada gravado
diz "Nenhuma produção registrada hoje." (ou na janela).

### Comandos avulsos {#single-commands}

"Dispare um comando isolado nesta unidade, fora de um procedimento." Cada linha é desenhada
só onde o modelo declara a biblioteca de que ela dispara:

| Linha | Controles | O que ela faz | Esmaecida quando |
|---|---|---|---|
| Snapshot | Um seletor de datalog e **Capturar** | "Registrar uma linha de datalog agora como uma execução concluída em Históricos": uma linha do datalog escolhido vira uma execução que nasce concluída. | Sem Executar procedimentos, a unidade ocupada (preparando, em execução, pausada ou salvando), a unidade ou a estação recusando operações de execução, ou um snapshot já em curso. |
| Avaliar agora | Um seletor de datalog, um seletor de avaliação e **Avaliar** | "Capturar uma linha e julgá-la contra a avaliação agora"; o veredito é gravado nos Históricos. Desenhada só onde o modelo tem datalog e avaliação. | O mesmo do Snapshot. |
| Aplicar receita | Um seletor de receita instantânea e **Aplicar** | "Escrever os setpoints da receita uma vez pelo funil (nenhuma execução é registrada)"; o diário é o registro. Só receitas Instantâneas são oferecidas. | Sem Executar procedimentos, a unidade ou a estação recusando operações de execução, ou uma aplicação em curso. Ela continua disponível com a unidade ocupada. |

Enquanto a unidade está ocupada, o cartão explica: "Snapshot e Avaliar ficam indisponíveis
enquanto esta unidade está preparando, executando, pausada ou salvando. Aplicar receita
continua disponível durante uma execução, mas não enquanto o intertravamento segura a
unidade: uma cadeia disparada, uma que aguarda rearme e uma cuja leitura está indisponível
recusam o comando." O desfecho de cada comando aparece no feed de ações da barra de status
("Snapshot registrado. Veja em Históricos.", "Avaliada. O veredito está registrado em
Históricos.", "Receita aplicada." ou a recusa). Os seletores começam no primeiro item de cada
biblioteca e guardam a sua escolha enquanto a entrada ficar aberta.

### Uma tela como cartão {#a-screen-as-a-card}

Um painel também pode carregar uma das telas do modelo como cartão, na altura escolhida no
painel (de 120 a 1200 px, 320 por padrão), encabeçado pelo nome da tela. O cartão roda a
definição única de tela do modelo resolvida para esta unidade: cada canal abstrato
respondido com a origem vinculada da própria unidade. Ela cresce até preencher o cartão e
nunca rola; a página é que rola. Os comandos dela seguem a regra do Process acima (só
Executar procedimentos), e uma tela sem nada nela é deixada de fora.

## A tela de uma unidade na View {#a-units-screen-on-view}

Uma tela de modelo marcada com **Mostrar em View** na linha Dashboards dela coloca uma
entrada por unidade na mesma lista, chamada `Modelo · Unidade · Tela`. Ela não é uma pilha
de cartões: o palco a roda no canvas como qualquer dashboard, resolvida para a unidade dela,
com a preferência de barra de status e o ícone escolhidos na tela do modelo. Os comandos
dela exigem só Executar procedimentos, ver a tela exige Ver modelos, e ela é editada na
linha Dashboards do modelo ([Dashboards de um modelo](process-dashboards)), onde o mesmo
editor abre com os canais abstratos do modelo encabeçando toda lista de endereços.

## O que um painel de unidade não faz {#what-a-unit-panel-does-not-do}

Ele nunca é editado, copiado nem reordenado na View, nunca é arquivado pelo modelo (só por
você, uma entrada de unidade por vez), e nunca carrega a lista Visível para. Ele não grava
nada por conta própria: um snapshot, uma avaliação ou uma execução é gravado pelos serviços
do Process e relido nos [Históricos](histories). E ele nunca desenha um cartão para o qual a
estação não tem nada, então um cartão que falta na pilha é um cartão sem nada a mostrar, não
um cartão desligado.