Important : AutomationView ne contient aucune IA integree, aucun assistant interne, aucun mode "agent IA" et aucune integration de LLM. Il n'y a ni bouton ni commande IA dans le produit. Cette page explique comment pointer un assistant de code externe et tiers (par exemple Claude Code, Cursor ou GitHub Copilot) vers vos fichiers de projet. C'est un outillage que vous configurez vous-meme - ce n'est pas une fonctionnalite d'AutomationView.
AutomationView stocke les sequences dans de simples fichiers Python (.seq) et la configuration du projet en Python (.machine). Comme ce sont des fichiers texte ouverts et lisibles sur le disque, tout assistant IA externe capable de lire et modifier des fichiers dans un dossier peut aussi lire et modifier votre projet AutomationView, sans plugin ni integration speciale. AutomationView n'embarque ni n'appelle un tel outil.
AutomationView stocke les sequences sous forme de classes Python basees sur la bibliotheque automation_machine. Le Python ordinaire est deja compris par les assistants externes : un outil que vous executez vous-meme peut donc :
L'assistant modifie les memes fichiers qu'AutomationView charge. A l'enregistrement, AutomationView reanalyse le fichier et met a jour le diagramme visuel comme d'habitude.
C'est equivalent a ouvrir les fichiers dans n'importe quel editeur de texte : les fichiers sont ouverts, donc des outils externes peuvent travailler avec. AutomationView ne genere pas de sequences a votre place et n'execute aucune IA en votre nom.
Les assistants externes travaillent mieux si vous leur fournissez un briefing ecrit de l'API automation_machine et des regles de votre projet. Une convention courante (utilisee par Claude Code) consiste a placer un fichier CLAUDE.md a la racine du projet, que l'outil lit en debut de session. C'est une convention de l'outil externe, pas une fonctionnalite d'AutomationView : le produit ne lit pas, ne genere pas et n'exige pas ce fichier.
Voir Qu'est-ce qu'un fichier CLAUDE.md ? pour le fonctionnement de cette convention externe. Voici un briefing de reference a adapter.
Copiez ceci dans un fichier de contexte que votre assistant lit (par exemple CLAUDE.md) 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 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 (une ou plusieurs 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]
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.
- Un ou plusieurs 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.
Ce sont des choses que vous pouvez faire avec un outil tiers sur les fichiers ouverts du projet. Ce ne sont pas des fonctionnalites d'AutomationView, et le produit ne garantit rien sur le resultat - relisez et validez toujours le code genere.
Decrivez la machine en langage courant et demandez a l'assistant 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."
"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."
Apres que l'assistant a ecrit un fichier, chargez-le dans AutomationView. Le panneau Diagnostics detecte les problemes structurels (blocages, etapes inaccessibles, conflits d'adresses). Le resultat de l'assistant ne fait pas autorite - ce sont les validateurs et votre propre relecture qui font foi.
| 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'assistant 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 de mon fichier de briefing ?" |