Plc

PlcService gère les données de l'automate de travail.
Il contient aussi une machine à état affichant l'état de l'automate de travail.
Il est intrinsèquement lié à TiaService, si la machine à état de TiaService change, la machine à état de PlcService changera certainement.

Importation

      
import {inject} from "inversify";
import "reflect-metadata";
import PlcService from "@adclz/fevermainlib/services/plc";
 
export default class MyClass {
    private PlcService: PlcService
 
    constructor(@inject(PlcService) PlcService: PlcService) {
        this.PlcService = PlcService
    }
}

📜 Champs

`PlcStateMachine`

PlcService.prototype.PlcStateMachine = PlcStatemachine

Type: PlcStateMachine

Etat reçu par le Manager.

Ce champ représente la machine à état qui définis le comportement global du service.

`MainFolder`

PlcService.prototype.MainFolder = Folder | null

Type: Folder | null

Dossier racine des blocs de programmes de l'automate vérrouillé.
Ce champ est récursif.

`InconsistentBlocks`

PlcService.prototype.InconsistentBlocks = Folder | null

Type: Folder | null

Dossier racine des blocs de programmes inconsistents de l'automate vérrouillé.
Ce champ est récursif.

`PlcDataUpdated`

PlcService.prototype.PlcDataUpdated = DataStatus

Type: DataStatus

Indicateur sur l'état d'actualisation du champ MainFolder.

`InconsistentBlocksUpdated`

PlcService.prototype.InconsistentBlocksUpdated = DataStatus

Type: DataStatus

Indicateur sur l'état d'actualisation du champ InconsistentBlocks.

Médiateur

📢 Notifications

`OnNewPlcState`

Indique un changement d'état de PlcState

      
import {OnNewPlcState} from "@adclz/fevermainlib/services/plc";
 
InjectedMediator.Notification(OnNewPlcState).Subscribe("MyClassId", NotificationData => {
    console.log(NotificationData)
                       
(parameter) NotificationData: PlcStateMachine
})

`OnNewPlcBlocks`

Indique une mise à jour des blocs du dossier racine de l'automate vérrouillé.

      
import {OnNewPlcBlocks} from "@adclz/fevermainlib/services/plc";
 
InjectedMediator.Notification(OnNewPlcBlocks).Subscribe("MyClassId", NotificationData => {
    console.log(NotificationData)
                       
(parameter) NotificationData: Folder
})

`OnNewInconsistentPlcBlocks`

Indique une mise à jour des blocs inconsistents de l'automate vérrouillé.

      
import {OnNewInconsistentPlcBlocks} from "@adclz/fevermainlib/services/plc";
 
InjectedMediator.Notification(OnNewInconsistentPlcBlocks).Subscribe("MyClassId", NotificationData => {
    console.log(NotificationData)
                       
(parameter) NotificationData: Folder
})

`OnPlcDataUpdated`

Indique un changement d'état de chargement des données de MainFolder.

      
import {OnPlcDataUpdated} from "@adclz/fevermainlib/services/plc";
 
InjectedMediator.Notification(OnPlcDataUpdated).Subscribe("MyClassId", DataStatus => {
    console.log(DataStatus)
                    
(parameter) DataStatus: DataStatus
})

`OnInconsistentBlocksUpdated`

Indique un changement d'état de chargement des données de InconsistentBlocks.

      
import {OnInconsistentBlocksUpdated} from "@adclz/fevermainlib/services/plc";
 
InjectedMediator.Notification(OnInconsistentBlocksUpdated).Subscribe("MyClassId", DataStatus => {
    console.log(DataStatus)
                    
(parameter) DataStatus: DataStatus
})

📄 Définitions

`Folder`

Folder représente les dossier et blocs du programme d'un automate de façon récursive.

import {Folder} from "@adclz/fevermainlib/plc";

interface Folder {
    Name: string
    Folders: Folder[]
    Blocks: Block[]
}

`Name`

Folder.Name = string

Nom du dossier.

`Folders`

Folder.Name = Array<Folder>

Liste des dossiers contenus dans ce dossier.

`Blocks`

Folder.Name = Array<Block>

Liste des Blocks contenus dans ce dossier.

`Block`

Block représente un bloc de programme

import {Block} from "@adclz/fevermainlib/plc";

enum BlockType {
    CodeBlock,
    DataBlock
}

interface Block {
    Name: string
    Adress: string
    FingerPrints: FingerPrint[]
    Sections: Sections
    Type: BlockType
    Content: IBlockContent
}

`Name`

Block.Name = string

Nom du bloc.

`Adress`

Block.Adress = string

Adresse exprimée en "%~"

`FingerPrints`

Block.Type = Array<FingerPrint>

Liste des empreintes.

`FingerPrint`

Empreinte indiquant l'état des propriétés du bloc. Vous pouvez utiliser la valeur de l'empreinte afin de surveiller les changements d'un bloc.

import {FingerPrint} from "@adclz/fevermainlib/plc";

enum FingerPrintId {
    Code,
    Properties,
    Comments,
    Interface,
    LibraryType,
    Texts,
    Alarms,
    Supervisions,
    TechnologyObject,
    Events,
    TextualInterface
}

interface FingerPrint {
    FingerPrintId: FingerPrintId
    Value: string
}

`Sections`

Block.Sections = Array<Section>

Liste des sections.

`Section`

Représente les différentes sections de l'interface d'un bloc.

import {Sections} from "@adclz/fevermainlib/plc";

interface Member {
    DataType: string
    Name: string
}

interface Sections {
    Input: Member[]
    Output: Member[]
    InOut: Member[]
    Static: Member[]
    Temp: Member[]
    Constant: Member[]
    Return: Member[]
}

`Type`

CodeBlock.Type = CodeBlockType

Type du block.

`Content`

CodeBlock.Content = IBlockContent

Contenu du block.

`IBlockContent`

Définit le contenu principal du bloc depuis le champ Content.

Type	Description
`CodeBlock`	`CodeBlock: Fb, Fc, Ob`
`DataBlock`	`DataBlock: InstanceDb, GlobalDb, ArrayDb`

import {CodeBlock, DataBlock} from "@adclz/fevermainlib/services/plc";

      
import {CodeBlock, DataBlock, Block, BlockType} from "@adclz/fevermainlib/services/plc";
 
export const MySwitchFunction = (Block: Block) => {
    switch (Block.Type) {
        case BlockType.CodeBlock:
            const MyCodeBlock = Block.Content as CodeBlock
                      
const MyCodeBlock: CodeBlock
            break;
        case BlockType.DataBlock:
            const MyDataBlock = Block.Content as DataBlock
                      
const MyDataBlock: DataBlock
            break;
    }
}

`DataBlock`

Contenu d'un CodeBlock

import {DataBlock} from "@adclz/fevermainlib/plc";

enum DataBlockType {
    Undef,
    InstanceDb,
    GlobalDb,
    ArrayDb,
}

interface DataBlock extends IBlockContent {
    Type: DataBlockType
    InstanceOfName: string
    InstanceOfType: string
}

`Type`

DataBlock.Type = DataBlockType

Type de DataBlock.

`InstanceOfName`

DataBlock.InstanceOfName = string

Nom de l'instance auquel est associé de bloc.

Uniquement si le bloc est de type InstanceDB.

`InstanceOfType`

DataBlock.InstanceOfType = string

Nom du type de donnée de l'instance auquel est associé de bloc.

Uniquement si le bloc est de type InstanceDB.

`CodeBlock`

Contenu d'un CodeBlock

import {CodeBlock} from "@adclz/fevermainlib/plc"

enum CodeBlockType {
    Undef,
    Fb,
    Fc,
    Ob
}

interface Instance {
    InstanceName: string
    InstanceOf: string
    Scope: string
}

interface CodeBlock extends IBlockContent {
    Type: CodeBlockType
    Instances: Instance[]
}

`Type`

CodeBlock.Type = CodeBlockType

Type de CodeBlock.

`Instances`

CodeBlock.Instances = Array<Instance>

Liste des instances contenues dans ce bloc.

Seul un bloc de type Fb peut contenir des instances.

`InstanceName`

Instance.InstanceName = string

Nom de l'instance.

`InstanceOf`

Instance.InstanceOf = string

Nom du bloc instancié.

`Scope`

Instance.Scope = string

Portée de l'instance.

LocalVariable signifie que l'instance est déclarée dans la section du bloc.
GlobalVariable signifie que l'instance est déclarée à l'extérieur du bloc, soit dans un InstanceDb dédié, soit via la section InOut.

`PlcStateMachine`

Machine à état de PlcService.

`GetPlcData`

PlcStateMachine.prototype.GetPlcData = () => void

Demande l'obtention des derniers blocs de l'automate vérrouillé.

Cette méthode est appellée automatiquement par TiaStateMachine.

`GetInconsistentData`

PlcStateMachine.prototype.GetInconsistentData = () => void

Demande l'obtention des derniers blocs inconsistents de l'automate vérrouillé.

Cette méthode est appellée automatiquement par TiaStateMachine.

`State`

PlcStateMachine.prototype.State = PlcState

PlcState représente l'état actuel de la machine à état.
Utilisez cet énumérateur plutôt que instanceof d'une classe qui hérite de TiaStateMachine.

Statut	Description
`Offline`	`Etat initial, aucun automate vérrouillé`
`Inconsistent`	`L'automate vérouillé est inconsistent`
`PlcOnline`	`L'automate vérouillé est en ligne directe avec Tia`
`Ready`	`L'automate est prêt pour la lecture des blocs`
`Done`	`La lecture des blocs est terminée`

enum PlcState {
    Offline,
    Inconsistent,
    PlcOnline,
    Ready,
    Done
}

`DataStatus`

Indicateur de mise à jour.

type DataStatus = { Updated: boolean, Message?: string }

DataStatus vous permet de savoir si une mise des données viens de de produire.

Si Updated est à true
Les données viennent d'être mises à jour avec succès.
Si Updated est à false
Les données n'ont pas encore été mises à jour.
Si Updated est à false et Message est défini
Les données n'ont pas pu être mise à jour et Message contient la raison de de l'échec.

ServicesLogs

ServicesProcess