Concevoir un contrôleur industriel économique avec le Raspberry Pi 3

Peu d'opérations industrielles dans les petits ateliers impliquent simultanément des environnements d'exploitation difficiles, une haute capacité E/S et des exigences de fonctionnalités complexes pour lesquelles les contrôleurs logiques programmables (PLC) ont été initialement conçus. Même s'il existe des versions réduites des PLC, les concepteurs peuvent désormais choisir parmi une gamme diversifiée de solutions matérielles et logicielles open-source économiques pour la surveillance et le contrôle industriels.

Parmi ces solutions figure le petit dispositif Raspberry Pi 3 de la Fondation Raspberry Pi avec ses cartes d'extension associées. Cet article décrit les principales caractéristiques du Raspberry Pi 3 avant d'aborder son mode d'utilisation pour les applications de surveillance et de contrôle.

Pourquoi utiliser Raspberry Pi pour le contrôle industriel dans les petits ateliers ?

Pour de nombreuses opérations légères, la plateforme Raspberry Pi 3 offre une solution économique avec des capacités de performances considérables. Entièrement capable de gérer des tâches d'automatisation industrielle dédiées, la carte Raspberry Pi 3 combine un processeur basé sur ARM^® Cortex^®-A53 de Broadcom, 1 Go de RAM, des interfaces numériques et une connectivité Wi-Fi et Bluetooth. Le processeur proprement dit est un dispositif à système sur puce (SoC) hautes performances intégrant un processeur à quatre cœurs ARM Cortex-A53 avec 512 Ko de cache L2 et 54 GPIO disposées en trois rangées.

Chaque GPIO prend en charge deux à six fonctions alternatives différentes, notamment les modulateurs de largeur d'impulsion, les horloges et les interfaces série. Les développeurs peuvent utiliser les GPIO non attribuées comme des lignes d'interruption, des entrées ou des sorties pouvant fournir jusqu'à 16 mA (jusqu'à 50 mA au total par rangée de GPIO).

Tout comme les autres produits de la gamme Raspberry Pi, le Raspberry Pi 3 est conçu pour simplifier le développement embarqué pour les débutants, tout en étant assez puissant pour répondre aux besoins des développeurs expérimentés ayant des exigences de traitement plus complexes et plus puissantes.

Pour commencer, les développeurs doivent simplement connecter les ports vidéo de la carte à leurs écrans et les ports USB au clavier et à la souris. Pour la conception logicielle, les développeurs peuvent concevoir un vaste écosystème pris en charge par le système d'exploitation Raspbian gratuit basé sur Linux de la Fondation Raspberry Pi, et chargé via une carte mémoire insérée dans l'interface micro SD de la carte.

Ajout de capacités industrielles

Outre ses performances et sa facilité de développement, l'approche simplifiée du Raspberry Pi pour étendre ses fonctionnalités lui permet d'être adapté aux nombreuses exigences des applications d'automatisation industrielle. Pour ajouter des capacités matérielles, les développeurs doivent simplement brancher une carte d'extension appelée HAT (Hardware Attached on Top) sur la carte Raspberry Pi 3. Tout comme les systèmes industriels plus complexes, la carte HAT fournit une approche standard pour son identification et la configuration automatique des GPIO et des pilotes au besoin. Par conséquent, les développeurs peuvent directement mettre à niveau leur système Raspberry Pi pour les applications industrielles simplement en connectant la carte Automation HAT PIM213 de Pimoroni (Figure 1).

Figure 1 : Les développeurs peuvent mettre à niveau une carte Raspberry Pi 3 de base pour l'automatisation industrielle en connectant des cartes d'extension spécialisées comme la carte Automation HAT de Pimoroni. (Source de l'image : Pimoroni)

Spécialement conçue pour la surveillance et le contrôle des systèmes d'automatisation, la carte Automation HAT de Pimoroni combine plusieurs canaux E/S, notamment des entrées analogiques et numériques, des sorties alimentées et des commandes de relais. En plus d'une tenue en tension de 24 V, les canaux E/S fournissent une mise en tampon importante d'entrées et de sorties. Par exemple, les sorties de relais supportent jusqu'à 2 A pour pouvoir commander des composants basse consommation de 24 V comme l'électrovanne 81 546 001 de Crouzet.

Pour le développement logiciel avec la carte Automation Hat, Pimoroni propose un module Python associé nécessitant uniquement quelques lignes de codes pour pouvoir utiliser les fonctionnalités matérielles de la carte HAT. Le module Pimoroni importé dans un programme Python crée des objets logiciels pour l'entrée analogique, l'entrée numérique, la sortie numérique, la sortie de relais et la commande de voyants LED, qui incluent respectivement les fonctions correspondantes de lecture/écriture de niveau inférieur (Liste 1).

class AnalogInput(object):

    type = 'Analog Input'

    def __init__(self, channel, max_voltage, led):

        self._en_auto_lights = True

        self.channel = channel

        self.value = 0

        self.max_voltage = float(max_voltage)

        self.light = SNLight(led)

    def auto_light(self, value):

        self._en_auto_lights = value

        return True

    def read(self):

        """Return the read voltage of the analog input"""

        return round(self.value * self.max_voltage, 2)

    def _update(self):

        self.value = ads1015.read(self.channel)

def _auto_lights(self):

        if self._en_auto_lights:

            adc = self.value

            self.light.write(max(0.0,min(1.0,adc)))

Liste 1 : Le module Python de Pimoroni pour la carte Automation HAT simplifie le développement en traitant des transactions détaillées comme la lecture d'un convertisseur analogique-numérique (CAN) embarqué. (Source de l'image : Pimoroni)

Chaque objet détermine le canal correspondant et les autres données associées. Par exemple, lors de sa création, l'objet d'entrée analogique inclut la tension maximum pour la broche associée (voir fonction d'initialisation [init] dans la Liste 1). Pour effectuer une conversion du convertisseur analogique-numérique (CAN), l'objet CAN envoie une requête au module CAN sous-jacent (ads1015.read dans la Liste 1). Le module CAN, à son tour, effectue les transactions I²C de niveau inférieur nécessaires pour configurer le CAN et pour effectuer la conversion avant de renvoyer la valeur sous une forme utile (Liste 2).

class ads1015:

    def __init__(self, i2c_bus=None, addr=ADDR):

        self._over_voltage = [False] * 4

        self.i2c_bus = i2c_bus

        if not hasattr(i2c_bus, "write_i2c_block_data") or not hasattr(i2c_bus, "read_i2c_block_data"):

            raise TypeError("Object given for i2c_bus must implement write_i2c_block_data and read_i2c_block_data")

        self.addr = addr

    def read(self, channel=0, programmable_gain=PGA_4_096V, samples_per_second=1600):

        # sane defaults

        config = 0x0003 | 0x0100

        config |= SAMPLES_PER_SECOND_MAP[samples_per_second]

        config |= CHANNEL_MAP[channel]

        config |= PROGRAMMABLE_GAIN_MAP[programmable_gain]

        # set "single shot" mode

        config |= 0x8000

        # write single conversion flag

        self.i2c_bus.write_i2c_block_data(self.addr, REG_CFG, [(config >> 8) & 0xFF, config & 0xFF])

        delay = (1.0 / samples_per_second) + 0.0001

        time.sleep(delay)

        data = self.i2c_bus.read_i2c_block_data(self.addr, REG_CONV)

        value = ((data[0] << 4) | (data[1] >> 4))

        if value & 0x800:

            value -= 1 << 12

        value /= 2047.0 # Divide down to percentage of FS

        value *= float(programmable_gain)

        value /= 3300.0 # Divide by VCC

        return value

...

Liste 2 : Une requête d'une fonction de niveau supérieur de conversion CAN initie une commande de lecture, qui effectue une écriture du bus I²C pour démarrer la conversion et se met en veille jusqu'à la fin de la conversion, puis effectue une lecture du bus I²C pour recueillir le résultat. (Source de l'image : Pimoroni)

Pour le développeur, cependant, la lecture d'une valeur analogique nécessite uniquement l'exécution de la fonction de lecture de niveau supérieur (.read()) de l'entrée analogique spécifiée (.one) pour l'objet analogique :

          value = automationhat.analog.one.read()

La bibliothèque prend en charge ce modèle simple pour les autres fonctionnalités HAT et l'activation ou la désactivation d'un relais consiste en une simple requête :

          automationhat.relay.write(1) # 1 = ON, 0 = OFF

Options flexibles

La carte Automation HAT de Pimoroni offre la fonctionnalité E/S de base nécessaire pour une petite application d'automatisation industrielle, mais les développeurs peuvent choisir parmi une gamme diversifiée de cartes HAT disponibles pour tous les types de fonctions nécessaires à des applications spécialisées comme l'automatisation industrielle. Par exemple, la carte RTC HAT 3013 d'Adafruit fournit une fonctionnalité d'horloge temps réel (RTC), qui n'est pas une fonctionnalité standard de la carte proprement dite. Les concepteurs Raspberry Pi s'attendent à ce que les développeurs maintiennent la connexion Internet de la carte pour qu'elle puisse utiliser le protocole NTP (protocole d'heure réseau) afin de conserver l'heure. Par conséquent, une horloge temps réel externe comme la carte RTC HAT d'Adafruit est nécessaire pour les conceptions qui risquent une perte de connexion Internet accidentelle ou voulue.

L'ajout de fonctionnalités telles qu'une horloge temps réel permet aux développeurs de ne pas se limiter à une seule carte HAT dans une conception pour l'automatisation industrielle. Les développeurs peuvent empiler plusieurs cartes HAT sur une carte Raspberry Pi. Même si la plupart des cartes HAT sont empilables, les développeurs peuvent avoir à ajouter des embases d'empilage comme la 2223 d'Adafruit pour compléter l'assemblage ou les douilles-entretoises M2.5 pour éviter tout contact entre les cartes HAT ou avec la carte de base.

En utilisant des embases d'empilage et des douilles-entretoises, les développeurs peuvent facilement empiler une carte HAT comme la carte HAT moteur 2348 d'Adafruit pour l'ajout des variateurs moteurs nécessaires dans de nombreuses applications d'automatisation industrielle. Chaque carte HAT moteur 2348 peut commander deux moteurs pas-à-pas ou quatre moteurs CC. En fait, les développeurs peuvent empiler jusqu'à 32 cartes d'extension pour prendre en charge jusqu'à 64 moteurs pas-à-pas ou 128 moteurs CC (Figure 2).

Figure 2 : Les développeurs peuvent empiler plusieurs cartes HAT moteur 2348 d'Adafruit pour prendre en charge jusqu'à 64 moteurs pas-à-pas ou 128 moteurs CC dans une conception. (Source de l'image : Adafruit)

Comme pour la carte Automation HAT de Pimoroni, la carte HAT moteur 2348 d'Adafruit peut être programmée à l'aide de quelques commandes Python simples. Le logiciel d'exemple d'Adafruit pour la carte HAT moteur montre même les modèles de conception de base pour utiliser le module de threading Python pour exécuter plusieurs moteurs en parallèle (Liste 3).

from Adafruit_MotorHAT import Adafruit_MotorHAT, Adafruit_DCMotor, Adafruit_StepperMotor

import threading

# create a default object, no changes to I2C address or frequency

mh = Adafruit_MotorHAT()

# create empty threads (these will hold the stepper 1 and 2 threads)

st1 = threading.Thread()

st2 = threading.Thread()

. . .

myStepper1 = mh.getStepper(200, 1)      # 200 steps/rev, motor port #1

myStepper2 = mh.getStepper(200, 2)      # 200 steps/rev, motor port #1

myStepper1.setSpeed(60)          # 30 RPM

myStepper2.setSpeed(60)          # 30 RPM

stepstyles = [Adafruit_MotorHAT.SINGLE, Adafruit_MotorHAT.DOUBLE, Adafruit_MotorHAT.INTERLEAVE, Adafruit_MotorHAT.MICROSTEP]

def stepper_worker(stepper, numsteps, direction, style):

    #print("Steppin!")

    stepper.step(numsteps, direction, style)

    #print("Done")

while (True):

    if not st1.isAlive():

        randomdir = random.randint(0, 1)

        if (randomdir == 0):

            dir = Adafruit_MotorHAT.FORWARD

        else:

            dir = Adafruit_MotorHAT.BACKWARD

        randomsteps = random.randint(10,50)

        st1 = threading.Thread(target=stepper_worker, args=(myStepper1, randomsteps, dir, stepstyles[random.randint(0,3)],))

        st1.start()

    if not st2.isAlive():

        randomdir = random.randint(0, 1)

        if (randomdir == 0):

            dir = Adafruit_MotorHAT.FORWARD

        else:

            dir = Adafruit_MotorHAT.BACKWARD

        randomsteps = random.randint(10,50)

        print("%d steps" % randomsteps)

        st2 = threading.Thread(target=stepper_worker, args=(myStepper2, randomsteps, dir, stepstyles[random.randint(0,3)],))

        st2.start()

Liste 3 : Le module Python pour carte HAT moteur d'Adafruit inclut un logiciel d'exemple comme cet extrait illustrant l'utilisation de commandes de contrôle simples et l'utilisation du module de threading Python pour contrôler deux moteurs pas-à-pas. (Source de l'image : Adafruit)

Pour les fonctionnalités non incluses dans les cartes HAT disponibles, les développeurs n'ont pas à se limiter au format HAT. Le shield Arduino DFR0327 de DFRobot, le kit de démarrage GrovePi+ de Seeed Technology et le shield Click MIKROE-2756 de MikroElektronika permettent aux développeurs d'accéder aux diverses gammes disponibles de shields Arduino, dispositifs Grove et cartes Click MikroBUS, respectivement.

À l'aide de ces cartes, les développeurs peuvent rapidement ajouter une prise en charge pour des interfaces CAN standard en installant une carte Click CAN MIKROE-988 de MikroElektronika et une carte Click MIKROE-1296 dédiée aux boucles de courant 4-20 mA.

Finaliser une conception pour un petit atelier

Même après avoir rapidement configuré la conception basée sur Raspberry Pi avec la fonctionnalité d'extension requise, les développeurs perdent souvent du temps dans la conception de l'interface utilisateur adéquate. Avec le Raspberry Pi 3, les développeurs peuvent connecter la conception au service cloud Adafruit IO pour fournir un retour graphique et un contrôle des processus d'automatisation aux utilisateurs. Le service cloud permet aux développeurs de créer des flux simples de données et d'informations de traitement (Liste 4), et de concevoir des tableaux de bord permettant aux utilisateurs de surveiller et de contrôler les projets via un navigateur Web sur un ordinateur de bureau, un smartphone ou un autre dispositif mobile (Figure 3).

# Import library and create instance of REST client.

from Adafruit_IO import Client

aio = Client('YOUR ADAFRUIT IO KEY')

# Send the value 100 to a feed called 'Foo'.

aio.send('Foo', 100)

Liste 4 : Les développeurs peuvent facilement diffuser les données de leur application d'automatisation industrielle sur le cloud Adafruit IO pour les afficher et les contrôler. (Source de l'image : Adafruit)

Figure 3 : Les développeurs peuvent afficher les informations de leurs applications d'automatisation industrielle basées sur Raspberry Pi 3 et les contrôler à l'aide du tableau de bord Adafruit IO. (Source de l'image : Adafruit)

La combinaison d'un développement logiciel simplifié, de différentes cartes d'extension et de la carte Raspberry Pi hautes performances fournit une solution adaptée aux applications d'automatisation industrielle à petite échelle. Cependant, dans certaines de ces applications, les développeurs peuvent avoir besoin d'un contrôle de temporisation plus performant que celui fourni dans les configurations utilisant une horloge temps réel, comme la RTC HAT 3013 d'Adafruit.

La carte RTC HAT 3013 est basée sur le circuit intégré RTC DS3231 de Maxim Integrated, qui fournit deux alarmes programmables et un signal de sortie à onde carrée. Les développeurs peuvent utiliser ces alarmes pour générer une interruption après un nombre spécifié de jours, d'heures, de minutes et de secondes, ou utiliser l'onde carrée pour générer l'interruption à une fréquence de 1 Hz. Pour les applications nécessitant des interruptions périodiques à une fréquence supérieure à 1 Hz, les développeurs devront développer des fonctions logicielles personnalisées à l'aide du temporisateur système du processeur ou concevoir des compteurs matériels personnalisés capables de générer une interruption à la fréquence souhaitée.

Dans les applications nécessitant une résolution de temporisation plus rapide, la latence de réponse déterministe est tout aussi importante. À des fréquences élevées, la variabilité de la latence de réponse dans le système d'exploitation Raspbian standard peut compromettre la précision. Même si le système standard peut certainement fournir une réponse suffisamment déterministe avec une résolution en millisecondes, les développeurs pourraient avoir à adopter des approches utilisant le patch Linux PREEMPT_RT pour répondre aux exigences de résolution plus déterministes et plus performantes.

Conclusion

Les PLC conventionnels offrent des capacités qui vont généralement au-delà des exigences et des budgets de la plupart des opérations industrielles légères dans les ateliers de fabrication, d'usinage et de prototypage à petite échelle. Pour ces applications, les opérateurs rencontrent généralement des exigences plus modestes qui correspondent largement aux capacités du Raspberry Pi 3.

À l'aide du Raspberry Pi 3 et des cartes d'extension adéquates, les développeurs peuvent rapidement mettre en œuvre des systèmes d'automatisation industrielle dédiés pouvant répondre aux exigences d'une vaste gamme d'opérations dans les petits ateliers.