Les sequences AutomationView sont de simples fichiers Python. Tout assistant IA de code — Claude Code, GitHub Copilot, Cursor ou un LLM local — peut lire, ecrire et raisonner sur les fichiers .seq et .machine directement, sans plugin ni integration speciale.
AutomationView stocke les sequences sous forme de classes Python. Cela les rend naturellement lisibles par les outils IA, qui peuvent :
Aucun export, aucune conversion. L'IA modifie les memes fichiers qu'AutomationView charge.
La facon la plus efficace de travailler avec l'IA est d'ajouter un fichier CLAUDE.md a la racine de votre projet AutomationView. Ce fichier sert de briefing persistant : l'IA le lit au debut de chaque session et comprend votre projet sans que vous ayez a reexpliquer l'API.
Conseil :
CLAUDE.mdest le format de briefing natif de Claude Code. D'autres outils IA peuvent egalement le lire — renommez-leAI.mdouAGENTS.mdsi votre outil requiert un nom de fichier different.
Copiez ce fichier a la racine de votre projet AutomationView et ajustez les sections specifiques au projet :
# Projet AutomationView
Ceci est un projet d'automatisation AutomationView. Les programmes sont ecrits
sous forme de classes Python avec la bibliotheque `automation_machine`. Les
fichiers utilisent les extensions `.seq` (sequences) et `.machine` (configuration
du projet) -- les deux sont du Python valide charge par un hook d'import personnalise.
Les variables sont inferees automatiquement. Il n'y a pas de classe IO. Le
VariableExtractor detecte toutes les variables depuis les noms des actions,
les conditions de transition et les operandes. Vous n'ecrivez que des fichiers
.seq et .machine.
## Structure du projet
projet/
main.machine # Configuration du projet (un seul par projet)
NomSequence.seq # Une classe de sequence par fichier
## Types de fichiers
| Extension | Role | Classe de base |
|------------|------------------------|----------------|
| `.seq` | Logique de la sequence | `Sequence` |
| `.machine` | Configuration projet | `Machine` |
## Imports
N'importer que ce qui est utilise :
# Dans les fichiers .seq
from automation_machine import Sequence, StepType
from automation_machine import ActionQualifier # uniquement si qualificatif non-N
from automation_machine import ActionInstruction # timers, compteurs, instructions
from automation_machine import ActionOperand # operandes arithmetiques/comparaison
# Dans les fichiers .machine -- uniquement cet import, jamais de classes de sequence
from automation_machine import Machine
## Creation des etapes
Les variables d'etape utilisent self.s0, self.s1, self.s2, etc. Le parametre
name est le label d'affichage de l'etape.
# Etape initiale (exactement une par sequence)
self.s0 = self.add_step(StepType.INITIAL, name="0", comment="Position initiale")
# Etape normale (StepType.NORMAL est le defaut -- omettre)
self.s1 = self.add_step(name="1", comment="Sortir le verin")
## Signature complete de add_action()
step.add_action(
name, # Nom de la variable (positionnel, requis)
description="",
qualifier=ActionQualifier.N, # Omettre pour le qualificatif N par defaut
instruction=None, # Enum ActionInstruction ou chaine pour plugins
duration=None, # ms -- qualificatifs temporises et timers
operands=None, # List[ActionOperand]
condition=None,
code=None,
preset_value=None, # pour les instructions compteur
parameters=None, # Dict[str, Any] pour les actions de plugins
comment=None,
)
Schemas courants :
# Action N (defaut -- le plus courant, omettre le qualificatif)
self.s1.add_action("verin_avance", description="Sortie verin")
# Action timer
self.s3.add_action("T_Confirm", instruction=ActionInstruction.TON, duration=500,
description="Temporisateur de confirmation de position")
# S/R pour les operations non-physiques
self.s2.add_action("aspiration", qualifier=ActionQualifier.S)
self.s6.add_action("aspiration", qualifier=ActionQualifier.R)
# ActionOperand -- reference variable vs valeur litterale
ActionOperand("valeur_capteur")
ActionOperand("100", is_literal=True)
## Creation des transitions
Syntaxe des conditions : . (ET), + (OU), / (NON)
# Condition de base
self.add_transition(self.s0, self.s1, "start . /arret_urgence", comment="Demarrage cycle")
# Verification double capteur (toujours verifier le capteur oppose)
self.add_transition(self.s1, self.s2, "verin_av . /verin_ar")
# Sortie de temporisateur -- suffixe .q
self.add_transition(self.s3, self.s4, "T_Confirm.q")
# Reference inter-sequences : NomSequence.XNomEtape
self.add_transition(self.s5, self.s6, "Convoyeur.X3")
# Divergence ET (une source, plusieurs cibles)
self.add_transition(self.s0, [self.s1, self.s2], "start")
# Convergence ET (plusieurs sources, une cible)
self.add_transition([self.s3, self.s4], self.s5, "True")
## Actions de transition
Stocker la transition dans une variable pour lui ajouter des actions.
Schema typique pour les compteurs et signaux en impulsion.
# Compteur sur transition (P = une impulsion par franchissement)
self.t_count = self.add_transition(self.s4, self.s0, "/piece_presente . /compteur1.q")
self.t_count.add_action("compteur1", qualifier=ActionQualifier.P,
instruction=ActionInstruction.CTU, preset_value=3)
# Reset sur une autre transition
self.t_reset = self.add_transition(self.s4, self.s5, "/piece_presente . compteur1.q")
self.t_reset.add_action("compteur1", qualifier=ActionQualifier.R)
## References inter-sequences
NomSequence.XNomEtape
- NomSequence = valeur de self.name dans la sequence cible
- XNomEtape = prefixe X + valeur du parametre name de l'etape
- Prefixer avec / pour le NON : /Convoyeur.X3
## Variables dynamiques
Les sequences parametrisees utilisent des schemas {var}. Resolus par
add_instance() en utilisant le nom de l'instance comme prefixe.
class Verin(Sequence):
def setup(self):
self.name = "Verin"
self.s0 = self.add_step(StepType.INITIAL, name="0")
self.s1 = self.add_step(name="1")
self.s1.add_action("{sortie_av}")
self.s1.add_action("{T_Avance}", instruction=ActionInstruction.TON, duration=2000)
self.add_transition(self.s0, self.s1, "{cmd_avance}")
self.add_transition(self.s1, self.s2, "{T_Avance}.q")
self.add_transition(self.s2, self.s0, "/{cmd_avance}")
## Fichier Machine (.machine)
N'importer que Machine -- les classes de sequence sont resolues automatiquement.
from automation_machine import Machine
class ProjetMachine(Machine):
def __init__(self):
super().__init__()
self.name = "Nom du projet"
self.version = "1.0.0"
self.description = ""
self.author = ""
self.metadata = {"standard": "IEC 61131-3"}
def setup(self):
# add_instance prend des noms de classe sous forme de CHAINE -- pas de reference
self.add_instance("Verin", "magasin_1")
self.add_instance("Verin", "magasin_2")
## Qualificatifs d'action
| Qualificatif | Comportement |
|--------------|-------------------------------------------------------------------|
| N | DEFAUT -- actif pendant l'etape, omettre l'argument |
| S | Memorisation ON jusqu'au Reset -- non-physiques uniquement |
| R | Reset d'une action memorisee |
| P | Impulsion unique -- sur les actions de transition pour compteurs |
| D | Active apres un delai (ms) si l'etape reste active |
| L | Actif pour une duree (ms) puis s'arrete |
| SD | Memorisation Retardee -- reste meme si l'etape se desactive |
| DS | Retarde Memorise -- delai compte pendant l'etape, puis memorise |
| SL | Memorisation Limitee -- memorise, auto-reset apres la duree |
## Instructions d'action
Temporisateurs (requiert duration en ms) :
TON -- Retard a l'enclenchement TOF -- Retard au declenchement
TP -- Impulsion RTO -- Temporisateur retentif
Compteurs (requiert preset_value) :
CTU -- Comptage croissant CTD -- Comptage decroissant
CTUR -- CTU avec Reset CTDR -- CTD avec Reset
Bistable / Detection de front (pas d'argument supplementaire) :
SR -- Dominance Set RS -- Dominance Reset
R_TRIG -- Front montant F_TRIG -- Front descendant
Arithmetiques (requiert operands) :
ADD SUB MUL DIV MOVE
Comparaison (requiert operands, resultat booleen) :
GT GE LT LE EQ NE
Instructions de plugins : passer sous forme de chaine -- instruction="NOM_PLUGIN"
## Bonnes pratiques
Le qualificatif N est le defaut -- omettre l'argument pour les actionneurs physiques.
Une action N sur une variable doit appartenir a UNE seule sequence.
Regle double capteur -- toujours verifier les deux capteurs :
self.add_transition(s1, s2, "verin_av . /verin_ar")
self.add_transition(s5, s6, "verin_ar . /verin_av")
Confirmation par temporisateur -- TON sur l'etape, transition sur .q :
self.s3.add_action("T_Confirm", instruction=ActionInstruction.TON, duration=500)
self.add_transition(self.s3, self.s4, "T_Confirm.q")
Durees types : 300-500ms (position), 50-100ms (anti-rebond), 1000-2000ms (securite)
Etapes de synchronisation -- pour la coordination inter-sequences, pas d'action
physique sur les etapes de sync. Toute etape de sync doit avoir une etape de desync.
## Liste de verification
- Tout actionneur physique utilise le qualificatif N (omettre l'argument)
- S/R uniquement pour les operations non-physiques et non-dangereuses
- Qualificatif P sur les actions de transition pour les compteurs et signaux
- Toute transition double capteur verifie les deux : capteur . /oppose
- Instructions timer avec TON (ou TOF/TP/RTO) et duration
- Transitions timer avec suffixe .q
- Instructions compteur avec CTU/CTD et preset_value
- References inter-sequences au format NomSequence.XNomEtape
- Etapes de sync sans aucune action physique
- Toute sync a une desync correspondante
- Variables d'etapes self.s0, self.s1, etc.
- Exactement un StepType.INITIAL par sequence
- Arret d'urgence dans la condition de la transition de demarrage
- N'importer que ce qui est utilise
- Les fichiers .machine n'importent que Machine -- pas de classes de sequence
- add_instance utilise des noms de classe sous forme de chaine, pas de references
Remarque : Les variables sont inferees automatiquement depuis les noms des actions, les conditions de transition et les operandes. Vous ne declarez jamais de liste d'E/S -- utilisez des noms de variables descriptifs et le systeme de Gestion des Variables les detecte.
Decrivez la machine en langage courant et demandez a l'IA de produire le fichier .seq :
"Ecris une sequence pour un verin pneumatique. Capteurs : verin_av (avant), verin_ar (arriere). Sortie : verin_sortie. Le cycle demarre sur start_cmd, sort, confirme la position avec un timer de 300ms, puis rentre."
L'IA generera un fichier .seq complet avec confirmation par temporisateur, transitions a double capteur et structure conforme a la norme IEC 61131-3.
"J'ai 4 convoyeurs identiques. Cree une sequence Verin dynamique et un fichier machine qui instancie 4 copies nommees conv_1 a conv_4."
"Analyse cette sequence pour des problemes de securite, des confirmations de temporisateur manquantes, et les cas ou deux sequences pourraient ecrire la meme sortie."
"Ajoute une etape de surveillance d'arret d'urgence qui met un flag memoire et attend un reset manuel avant de retourner a l'etape initiale."
| Objectif | Conseil |
|---|---|
| Nommage precis des E/S | Mentionnez votre convention de nommage des le depart (ex. : "les entrees sont prefixees i_, les sorties o_") |
| Style coherent | Demandez a l'IA de suivre les schemas deja presents dans vos fichiers de projet |
| Machines complexes | Decrivez une sequence a la fois, puis demandez le fichier machine pour les coordonner |
| Synchronisation inter-sequences | Precisez explicitement quelles etapes se synchronisent entre les sequences |
| Relecture | Partagez le contenu du fichier et demandez "Est-ce que ceci respecte les regles du CLAUDE.md ?" |