Ada for Automation

Bonjour,

Présentation

« Ada for Automation » (A4A en version courte) est un cadre applicatif, ou framework, au code source ouvert, pour la conception d’applications d’automatisme industriel dans le langage Ada.

Il s’appuie sur la bibliothèque libmodbus pour permettre de réaliser un client ou un serveur Modbus TCP, ou encore un maître Modbus RTU.

Il s’appuie également sur les cartes de communication de la société Hilscher permettant de s’interfacer sur les principaux bus de terrain du marché comme AS-Interface, CANopen, CC-Link, DeviceNet, PROFIBUS, EtherCAT, Ethernet/IP, Modbus TCP, PROFINET, Sercos III, POWERLINK, ou VARAN.

Les technologies de bus de terrain vous permettent de piloter des installations de toutes tailles via des capteurs et actionneurs connectés individuellement sur le bus ou via des stations d’entrées / sorties déportées sur le bus.

Grâce à Ada, votre application d’automatisme peut s’exécuter sur différents matériels, du PC à l’embarqué, sous de multiples OS, notamment sous Linux et Windows, sans modifier le code de votre application.

Ada est un langage très puissant et néanmoins accessible avec lequel il est possible de créer toutes sortes d’applications de la plus simple à la plus étoffée.

Les outils, IDE, compilateur… le framework ainsi que de nombreuses bibliothèques sont libres.

Ada - In Strong Typing We Trust
Ada – In Strong Typing We Trust

Ada est un langage que je trouve particulièrement puissant et élégant, tout en restant relativement facile à apprendre pour un technicien ou un ingénieur en automatisme.

En fait, celui-ci retrouvera dans ce langage les concepts qu’il manipule au quotidien en utilisant son atelier de programmation d’automate favori – ou imposé -, avec une syntaxe claire rappelant le langage « Structured Text » de la norme IEC 61131-3, ce qui est somme toute normal puisque ce langage s’inspire notamment de Ada.

En intégrant avec « Ada for Automation » des bibliothèques comme Gnoga et Simple Components, il devient possible de réaliser des applications avec interface Web, disposant d’une connexion aux bases de données.

Tandis que GtkAda permettra de fournir une interface graphique évoluée à votre application, mosquitto-ada fournira un client permettant de publier et souscrire auprès d’un serveur Mosquitto implémentant le protocole MQTT et connectant de ce fait votre application au nuage tant vanté, cf. IoT, Industry 4.0, etc…

Objectifs

J’ai identifié quelques objectifs pour ce projet.

  • Disposer d’un langage adéquat pour des applications d’automatisme exigeantes, mais qui convienne aussi pour des applications basiques, multiplateforme.
  • Permettre au programmeur en automatisme de se former sur les paradigmes (sous-)utilisés dans les ateliers actuels, ce qui le rendra plus productif sur ces mêmes ateliers.
  • Permettre à Ada de sortir du ghetto élitiste où ses origines et son histoire l’ont enfermé, les applications sensibles dans les domaines militaire, nucléaire, aérospatial, de la finance, médical, ferroviaire…

Bien sûr, je ne prétends pas révolutionner le domaine. Je suis loin d’être un expert en Ada.

Et je connais les résistances au changement pour les avoir expérimentées.

« Ada for Automation » ne s’adresse pas aux inconditionnels de tel ou tel constructeur / atelier / langage.
Il est nécessaire d’avoir un peu de curiosité intellectuelle pour s’affranchir des réflexes acquis et s’aventurer hors des sentiers battus.
Il faudra un peu de temps aux personnes intéressées pour maîtriser les concepts et outils utilisés. Cependant les concepts sont universels et les outils libres. Je suis certain que les bénéfices en termes de formation et d’ouverture peuvent être considérables.

Je n’oppose pas les langages d’automatisme et Ada. Je pense qu’il y a de la place pour tous.
Mais je serais très heureux si ce langage pouvait trouver sa place dans la panoplie de l’automaticien.
Ada permettrait de résoudre la problématique de la portabilité qui n’est pas encore résolue avec PLCopen, plus sans doute par manque de volonté des fabricants que par une impossibilité technique.

Je crois aux vertus de l’exemplarité. Si les fruits sont bons, c’est que l’idée est bonne. C’est le sens, sinon la formule…

Je pense que l’on peut se limiter pour « Ada for Automation » à utiliser les concepts de base du langage, de façon à être le plus intelligible aux non-Adaïstes. Cela ne limite en rien l’utilisation de Ada pour l’application utilisateur.

Je suis depuis longtemps acquis aux idées du logiciel libre.
J’espère contribuer à cette révolution avec « Ada for Automation ».

Show me the code Dude !

Le code source de « Ada for Automation » est ouvert et vous pouvez le télécharger.

Si vous souhaitez avoir un aperçu d’un code Ada, voici ci-dessous un exemple tiré du livre :
Building Parallel, Embedded, and Real-Time Applications with Ada – Academic and Professional Books – Cambridge University Press

Ce bout de code constitue une application complète dans laquelle on trouve plusieurs tâches, des procédures, une boucle, des instructions d’attente…
Je ne vais pas les commenter, c’est juste pour montrer à quoi ressemble du code Ada, je vous laisse à votre découverte.

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Task_Identification; use Ada.Task_Identification;

procedure Tasks is
   type Color_Type is (Red, Green, Yellow, Blue);

   procedure Turn_On_LED (Color : in Color_Type) is
   begin
      Put_Line(Color_Type'Image (Color) & " on");
   end Turn_On_LED;

   procedure Turn_Off_LED (Color : in Color_Type) is
   begin
      Put_Line(Color_Type'Image (Color) & " off");
   end Turn_Off_LED;

   ---------------------------------------------------------
   task Flash_Red_LED is          -- Declare a singleton task
      pragma Storage_Size (1_000);
   end Flash_Red_LED;

   task body Flash_Red_LED is   -- Body of the task
      My_ID : Task_Id;
   begin
      My_ID := Current_Task;
      Put_Line ("RED'S ID is " & Image (My_ID));
      loop
         Turn_On_LED (Red);
         delay 0.5;
         Turn_Off_LED (Red);
         delay 0.5;
      end loop;
   end Flash_Red_LED;

   ---------------------------------------------------------
   task type Flash_LED (Color  : Color_Type; -- Declare a task type
                        Period : Natural) is
      pragma Storage_Size (1_000);
   end Flash_LED;

   task body Flash_LED is   -- Body of the task
      My_ID : Task_Id;
   begin
      My_ID := Current_Task;
      Put_Line (Color_Type'Image (Color) & "'S ID is " & Image (My_ID));
      loop
         Turn_On_LED (Color);
         delay Duration (Period) / 2;
         Turn_Off_LED (Color);
         delay Duration (Period) / 2;
      end loop;
   end Flash_LED;

   ---------------------------------------------------------
   -- Two task objects (variables)
   Yellow_LED : Flash_LED (Color  => Yellow,
                           Period => 4);
   Green_LED  : Flash_LED (Color  => Green,
                           Period => 3);
   -- A pointer to a task object
   type Flash_Ptr is access Flash_LED;
   Blue_LED : Flash_Ptr;

begin
   Put_Line ("Flashing LEDs");
   Blue_LED := new Flash_LED (Color  => Blue,
                              Period => 8);
   Put_Line ("Main task is done");
end Tasks;

Licence

J’ai opté pour la GNU General Public License V3 + GCC Runtime Library Exception en ayant commencé le projet sous licence GMGPL :
http://en.wikipedia.org/wiki/GNAT_Modified_General_Public_License

J’ai expliqué ce changement dans cet article.

Mais je ne suis pas un expert en licences.
Aussi, je suis ouvert à la discussion, sur ce sujet comme sur le projet dans son intégralité.

Vous trouverez ainsi en tête de chaque fichier de code ceci :

------------------------------------------------------------------------------
--                            Ada for Automation                            --
--                                                                          --
--                   Copyright (C) 2012-2016, Stephane LOS                  --
--                                                                          --
-- This library is free software;  you can redistribute it and/or modify it --
-- under terms of the  GNU General Public License  as published by the Free --
-- Software  Foundation;  either version 3,  or (at your  option) any later --
-- version. This library is distributed in the hope that it will be useful, --
-- but WITHOUT ANY WARRANTY;  without even the implied warranty of MERCHAN- --
-- TABILITY or FITNESS FOR A PARTICULAR PURPOSE.                            --
--                                                                          --
-- As a special exception under Section 7 of GPL version 3, you are granted --
-- additional permissions described in the GCC Runtime Library Exception,   --
-- version 3.1, as published by the Free Software Foundation.               --
--                                                                          --
-- You should have received a copy of the GNU General Public License and    --
-- a copy of the GCC Runtime Library Exception along with this program;     --
-- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    --
-- <http://www.gnu.org/licenses/>.                                          --
--                                                                          --
------------------------------------------------------------------------------

Cordialement,
Stéphane

Laisser un commentaire