# El espacio de direcciones de la unidad

> Todos los puntos que publica una unidad en Process.Model.Unit, su tipo y su significado, qué puntos son comandos escribibles, y qué puede leer de ahí un script de Logic.

Toda unidad publica sus datos de corrida como direcciones comunes de [Logic](logic) en
`Process.<Model>.<Unit>`, así que los paneles de control, las expresiones de Logic, el servidor OPC UA
embebido y el agente llegan a ellos sin ninguna tubería extra. La rama se recorre en la página Logic,
en "De otras páginas" ([Desde otras páginas](logic-from-other-pages)) y en todo selector de
dirección. Renombrar un modelo, una unidad, un canal, un campo de metadatos, una evaluación o un
criterio reemplaza las direcciones correspondientes y reescribe las referencias textuales vivas; los archivos grabados conservan
congelados los nombres de cuando se escribieron. Los segmentos son los nombres depurados: una unidad
llamada "Unidad 1" del modelo "Cámara climática" se direcciona como
`Process.Cámara_climática.Unidad_1`.

| Rama | Qué expone | Escribible |
| --- | --- | --- |
| `Channels.<Channel>` | El valor vinculado en vivo de cada canal, tipado como lo declara el canal. | Un canal escribible (papel Solo escritura o Lectura y escritura) es un punto escribible por el punto único de escritura; una fuente que tiene una corrida rechaza a cualquier otro escritor. |
| `Procedure.<point>` | El estado de la corrida, un escalar por punto (tabla más abajo). | No. |
| `Commands.<command>` | `Start`, `Hold`, `Resume`, `Stop`, `Abort` y `Comment`. | Sí: escribir despacha (tabla más abajo). |
| `Next.<point>` | El área de preparación que consume el siguiente Arranque. | Solo los campos de metadatos manuales. |
| `LastRun.<point>` | El registro de la última corrida que la unidad terminó ([LastRun](#lastrun)). | No. |
| `Productivity.Today.<branch>` y `Productivity.Rolling.<branch>` | La proyección de productividad de la unidad para cada periodo. | No. |

## Canales {#channels}

Un punto de canal lee el valor que hay detrás del vínculo de la unidad, proyectado al tipo de datos
del canal, y se lee como un hueco cuando el canal no está vinculado o su fuente no está disponible. En
un script de Logic el punto es una proyección tipada de solo lectura del tag o la variable vinculados,
nunca el tag mismo: `Value`, `ValueObject`, `ValueRaw`, `ValueScaled`, `ValueCalibrated`,
`ValueLimited`, `ValueRounded`, las conversiones `ValueToBool()`, `ValueToInteger()`,
`ValueToReal()`, `ValueToString()` y `ValueToDateTime()`, la calidad `State()`, las marcas
`SourceTimeStamp()` y `ApplicationTimeStamp()`, `Refresh()`, `Name` y `EngineeringUnit`. Los miembros
de la cadena de conversión responden para un vínculo a un tag; un vínculo a una variable responde el
valor y la marca de la aplicación.

## Procedure {#procedure}

Todo punto se calcula a partir de la corrida en vivo y se lee con calidad buena; un punto que no tiene
nada que decir se lee como un hueco.

| Punto | Tipo | Significado |
| --- | --- | --- |
| `Status` | Texto | `Preparing` mientras la unidad está reservada y todavía no existe ninguna corrida, `Idle` mientras nada la posee, y si no el estado de la corrida: `Running`, `Held`, `Saving`, `Completed`, `Aborted`, `Failed`. |
| `Running` | Booleano | Estrictamente el estado En marcha; nunca verdadero para la preparación, En pausa, Guardando ni la finalización. |
| `Busy` | Booleano | El tramo ocupado entero: la reserva, En marcha, En pausa, Guardando y el cierre final del archivo de la corrida. |
| `Verdict` | Texto | `Ok`, `Nok`, `Indeterminate` o `None`, escritos exactamente así, sin importar la palabra que muestren la interfaz o una etiqueta impresa: una comparación se escribe `Process.<Model>.<Unit>.Procedure.Verdict == "Nok"`. La evidencia juzgada se sigue leyendo después de que la corrida termina, hasta que arranca la siguiente. |
| `Mode` | Texto | El modo de la corrida activa, `Instant`, `Temporal` o `Controlled`; un comando suelto (instantánea, evaluar ahora) también informa. Hueco cuando está en reposo. |
| `ActiveProcedure` | Texto | El nombre de la corrida activa ("Procedimiento · Unidad"). Hueco cuando está en reposo. |
| `SegmentIndex` | Entero | El segmento actual del perfil temporizado, de base cero. Hueco sin perfil. |
| `CycleIndex` | Entero | El ciclo actual, de base cero. Hueco cuando está en reposo. |
| `CycleCount` | Entero | El total de ciclos de la corrida (1 para una sola pasada). Hueco cuando está en reposo. |
| `Cycle` | Texto | "2 / 10" para una corrida cíclica; un hueco cuando la corrida no es cíclica, para que una lectura vinculada muestre la marca de hueco en vez de una sola pasada engañosa. |
| `FailedCycles` | Entero | Los ciclos juzgados No conformes hasta ahora. Hueco cuando la corrida no es cíclica. |
| `SamplesEvaluated`, `SamplesOut`, `SamplesUnavailable`, `SamplesInvalid` | Entero | Los contadores de evidencia de la evaluación, actualizados de forma atómica por el motor de evaluación. Hueco sin evidencia juzgada. |
| `Elapsed` | Número decimal | Segundos desde que arrancó la corrida. Hueco cuando está en reposo. |
| `StartedAt` | Fecha y hora | Cuándo arrancó la corrida activa. Hueco cuando está en reposo. |
| `Metadata.<Field>` | Texto | Un punto por campo de metadatos del modelo: el valor que la corrida en curso congeló en el Arranque. Hueco cuando está en reposo y para un campo que esa corrida no pide; un campo dejado en blanco se lee como texto vacío. Es lo que una acción disparada en el Arranque lee de la corrida que empieza, ya que `Next.<Field>` muestra la siguiente. |

## Commands {#commands}

Leer un punto de comando responde "¿esto se puede ejecutar ahora?", así que un Botón vinculado se
desactiva solo; escribirlo despacha el comando por la consola de corridas, con la fuente de la
superficie que escribe registrada en el diario y con la identidad de quien lo presionó. Un comando es
una llamada de servicio, nunca la escritura de un punto en cola.

| Punto | Se lee verdadero cuando | Al escribirlo |
| --- | --- | --- |
| `Start` | La unidad no está ocupada, el runtime acepta operaciones, el enclavamiento está Normal y hay un procedimiento preparado. | Arranca el procedimiento preparado con los metadatos preparados. |
| `Hold` | Una corrida está En marcha y su procedimiento es Temporizado. | Congela la ventana. |
| `Resume` | Una corrida está En pausa y el enclavamiento está Normal. | Suelta la pausa. |
| `Stop` | Una corrida está En marcha. | Termina la corrida como Completada. |
| `Abort` | Una corrida está En marcha o En pausa. | Termina la corrida como Abortada. |
| `Comment` | Nunca: el punto no tiene lectura. | Anexa el texto escrito como comentario a la corrida activa, o como nota posterior a la corrida en la última corrida terminada de la unidad cuando está en reposo. Una unidad sin ninguna corrida lo rechaza ("La unidad no tiene ninguna corrida que comentar."), y el texto vacío también. |

Todo comando se lee falso mientras la estación rechaza escrituras (el runtime detenido).

## Next {#next}

| Punto | Tipo | Significado |
| --- | --- | --- |
| `Next.Procedure` | Texto | El nombre del procedimiento preparado. Aquí es de solo lectura: preparar se hace en la tarjeta Corrida del panel de unidad. |
| `Next.<Field>` | Texto | Un punto por campo de metadatos que pide el procedimiento preparado; la rama se rehace cuando la unidad se vuelve a preparar, y un campo de otro procedimiento se lee como un hueco. Un campo manual (de texto o numérico) es un punto de preparación escribible, que es lo que escribe un componente Entrada vinculado a él. Un campo secuencial es una predicción de solo lectura del identificador que compondría el contador ahora; leerlo nunca lo reserva. |

Preparar es de toda la estación, en memoria y transitorio: se restablece cuando la aplicación arranca
y el Arranque lo consume, no lo limpia.

## Productivity {#productivity}

Dos periodos, `Today` (desde la medianoche local) y `Rolling` (la ventana declarada en el modelo o en
la unidad), cada uno con tres ramas ([Productividad](process-productivity)):

| Rama | Puntos | Tipo |
| --- | --- | --- |
| `Summary` | `ProductivityPercent`, `YieldPercent`, `TypicalElapsedSeconds` | Número decimal; un hueco hasta que exista el denominador. |
| `Summary` | `Finalized`, `OK`, `NOK`, `Indeterminate`, `Unclassified`, `Aborted`, `Failed` | Conteos enteros. |
| `Outputs.<key>` | `Quantity`, `RatePerHour` | Número decimal; una clave por cantidad con nombre, o por procedimiento productivo cuando el modelo no declara ninguna cantidad. |
| `Procedures.<key>` | `Quantity`, `RatePerHour` y los puntos de resumen de arriba | Como arriba, por procedimiento productivo. |

Las claves se derivan del identificador estable y de la unidad de salida congelada, no del nombre
visible, así que un cambio de nombre nunca mueve una expresión. Todo punto es de solo lectura, y la
proyección se lee del índice de históricos, nunca de los archivos de corrida.

## LastRun {#lastrun}

El registro de la última corrida que la unidad terminó: cuál fue, cómo terminó, qué ingresó el
operador en el Arranque y cómo salió cada criterio. Es lo que lee una acción de Logic disparada en la
Finalización ([Acciones](process-actions#logic-action-commands)), y cualquier otro consumidor lo lee
igual: una pantalla que muestra la última pieza, una alarma, los servidores de la estación. Cuenta
toda corrida grabada de la unidad, también una fallida y una Instantánea o un Evaluar ahora; una
corrida importada nunca cuenta.

| Punto | Tipo | Significado |
| --- | --- | --- |
| `RunId` | Texto | El identificador de la corrida. |
| `Procedure` | Texto | El nombre del procedimiento como lo grabó la corrida. |
| `Status` | Texto | `Completed`, `Aborted` o `Failed`, escritos exactamente así. |
| `Verdict` | Texto | `Ok`, `Nok`, `Indeterminate` o `None`, escritos como en `Procedure.Verdict`; una corrida fallida se lee `None`. |
| `StartedAt`, `FinishedAt` | Fecha y hora | Cuándo arrancó la corrida y cuándo terminó. |
| `Elapsed` | Número decimal | Segundos desde el arranque hasta el final. |
| `CycleCount` | Entero | Los ciclos de la corrida (1 en una pasada única). |
| `FailedCycles` | Entero | Los ciclos juzgados No conformes. |
| `Metadata.<Field>` | Texto | Un punto por campo de metadatos del modelo: el valor que la corrida congeló en el Arranque. Un campo que la corrida no pidió se lee como hueco; un campo dejado en blanco se lee como texto vacío. |
| `Evaluations.<Evaluation>.<Criterion>.<point>` | Como abajo | Una carpeta por evaluación del modelo y, debajo, una por criterio, con el nombre del criterio, o con el de su canal cuando no tiene. |

Cada criterio lleva un resultado, plegado sobre todos los ciclos en que se juzgó, así que la
dirección es la misma para una pasada única y para una corrida de cien ciclos:

| Punto | Tipo | Significado |
| --- | --- | --- |
| `Outcome` | Texto | `Ok`, `Nok` o `Indeterminate`, escritos exactamente así: un ciclo No conforme da `Nok`; si no, un ciclo Indeterminado da `Indeterminate`; si no, `Ok`. |
| `Passed` | Booleano | Verdadero solo cuando `Outcome` es `Ok`. |
| `Value` | Número decimal | El valor medido del canal vigilado: la última muestra evaluada de la ventana, en modo Un punto la juzgada, del ciclo más reciente que midió uno. |
| `MinValue`, `MaxValue` | Número decimal | El menor y el mayor valor evaluado, sobre todos los ciclos. |
| `Limits` | Texto | Los límites como se grabaron, como `5 .. 45`. |
| `WorstExcursion` | Número decimal | La mayor distancia más allá de un límite, sobre todos los ciclos. |
| `FailedCycles` | Entero | Los ciclos que juzgaron este criterio No conforme. |

La rama tiene la forma del modelo, nunca la forma de la última corrida: cada campo de metadatos del
catálogo y cada criterio de cada evaluación es un punto, así que un script que nombra uno pasa la
validación antes de cualquier corrida, y después de una corrida de un procedimiento que juzgó por
otra evaluación.

| Situación | Qué leen los puntos |
| --- | --- |
| Ninguna corrida de la unidad ha terminado todavía | Un hueco con mala calidad, en cada punto. |
| Una corrida termina | El registro nuevo, ya en su lugar antes de que el `Procedure.Status` de la unidad diga que la corrida terminó. |
| Otra corrida de la unidad está en curso | El registro anterior, hasta que esa corrida termine. |
| La aplicación vuelve a arrancar | La última corrida terminada de la unidad, releída de su archivo poco después del arranque; un hueco hasta que se lee. |
| Un criterio que la última corrida no juzgó (de otra evaluación, o agregado después) | Un hueco en cada punto. |
| Dos evaluaciones, o dos criterios, cuyos nombres se leen igual | Nada: la dirección no se resuelve en ninguno de los dos, y la página de la evaluación lo dice ([Evaluaciones](process-evaluations#names-are-addresses)). |

Renombrar un campo de metadatos, una evaluación, un criterio o el canal de un criterio sin nombre
mueve estas direcciones como cualquier otro renombrado de esta página.

## Qué puede hacer un script {#what-a-script-may-do}

Los scripts de variable, de alarma y de acción de Logic pueden **leer** todo lo de aquí: valores de
canal, estado de la corrida, disponibilidad de un comando, valores preparados, la última corrida y
puntos de productividad. No pueden despachar un comando, escribir un campo de preparación ni anexar
un comentario; esas escrituras pertenecen a los consumidores explícitos de comandos: los paneles de
operación, los Botones y las Entradas de un panel de control, la
automatización de la unidad y las herramientas del agente.

Un punto de canal se lee como la proyección tipada de [Canales](#channels); cualquier otro punto de
aquí se lee como su valor simple, sin `.Value` detrás, a diferencia de una variable:

```js
if (Process.Oven_soak.Oven_1.LastRun.Verdict === "Ok") {
  Variables.Last_serial = Process.Oven_soak.Oven_1.LastRun.Metadata.Serial;
}
```