Aufbau eines kostengünstigen industriellen Controllers mit dem Raspberry Pi 3

Zur Verfügung gestellt von Nordamerikanische Fachredakteure von Digi-Key

Wenige kleine Unternehmen benötigen wirklich die Kombination von Robustheit, hoher I/O-Kapazität und komplexer Funktionalität, für die speicherprogrammierbare Steuerungen (PLCs) ursprünglich ausgelegt waren. Es sind zwar abgespeckte PLCs verfügbar, aber die Entwickler habe auch die Möglichkeit, auf der Suche nach effizienter industrieller Überwachung und Steuerung auf eine Vielzahl von kostengünstigen Hardware- und Softwarelösungen aus dem Open-Source-Bereich zurückzugreifen.

Ein Beispiel für eine derartige Lösung ist der kleine Raspberry Pi 3 der Raspberry Pi Foundation mit den entsprechenden Zusatzplatinen. In diesem Artikel werden die Haupteigenschaften des Raspberry Pi 3 beschrieben, bevor wir näher auf die Verwendung für Überwachung und Steuerung eingehen.

Raspberry Pi für die industrielle Steuerung in kleinen Unternehmen

Für viele kleinere Betriebe bietet die Plattform Raspberry Pi 3 eine kostengünstige Lösung mit hoher Leistungsfähigkeit. Das Board Raspberry Pi 3 ist in der Lage, dedizierte industrielle Automatisierungsaufgaben zu bewältigen und kombiniert einen Broadcom-Arm®-Cortex®-A53-basierten Prozessor, 1 GByte RAM und digitale Schnittstellen mit den Netzwerkstandards Wi-Fi und Bluetooth®. Der Prozessor selbst ist ein Hochleistungs-SoC-Baustein (System-On-Chip), in dem eine Quad-Core-ARM Cortex-A53-CPU mit 512 KB L2-Cache und 54 in drei Bänke aufgeteilte GPIOs integriert sind.

Jede GPIO unterstützt alternativ mindestens zwei und bis zu 6 Funktionen, darunter Pulsweitenmodulatoren, Zeitgeber und serielle Schnittstellen. Die Entwickler können beliebige nicht zugewiesene GPIOs als Interrupt-Leitung, Eingang oder Ausgang mit bis zu 16 Milliampere (mA) (bis zu 50 mA insgesamt pro GPIO-Bank) verwenden.

Wie auch andere Mitglieder der Raspberry Pi-Familie macht der Raspberry Pi 3 die Embedded-Entwicklung für Anfänger recht einfach und ist dabei so leistungsfähig, dass er auch die komplexeren und anspruchsvolleren Anforderungen von erfahrenen Entwicklern erfüllt.

Um loslegen zu können, müssen die Entwickler nur die Videoanschlüsse der Platine mit einem Display und die USB-Anschlüsse mit Tastatur und Maus verbinden. Was die Softwareentwicklung betrifft, so können die Entwickler auf einem breiten Ökosystem aufbauen, das auf dem von der Raspberry Pi Foundation unterstützten freien Linux-basierten Betriebssystem Raspbian basiert, das von einer Speicherkarte über die Mikro-SD-Schnittstelle geladen wird.

Hinzufügen von industriellen Merkmalen

Neben seiner Leistung und der einfachen Entwicklung macht die leichte Erweiterbarkeit seiner Funktionalität den Raspberry Pi für die vielfältigen Anforderungen der Automatisierung in der Industrie hervorragend geeignet. Wenn die Entwickler Hardwaremerkmale hinzufügen möchten, müssen sie nur eine als HAT (Hardware Attached on Top, aufgesetzte Hardware) bezeichnete Zusatzplatine auf die Raspberry Pi 3-Platine aufstecken. Ebenso wie bei komplexeren industriellen Systemen bietet das HAT einen Standardansatz zur Identifikation und zur automatischen Konfiguration der GPIOs und Treiber je nach Bedarf. So können die Entwickler den Raspberry Pi im Handumdrehen durch einfaches Einstecken des Automation-HAT PIM213 von Pimoroni (Abbildung 1) für industrielle Anwendungen aufrüsten.

Bild der Zusatzplatine Pimoroni Automation HAT

Abbildung 1: Die Entwickler können eine Raspberry-Pi-3-Standardplatine für die industrielle Automatisierung durch Aufstecken eines spezialisierten Zusatzplatine aufrüsten, z. B. mit dem Automation-HAT von Pimoroni. (Bildquelle: Pimoroni)

Das speziell für die Überwachung und Steuerung von Automatisierungssystemen gedachte Automation-HAT von Pimoroni verfügt über mehrere I/O-Kanäle, z. B. analoge und digitale Eingänge, Ausgänge mit Stromversorgung und Relaissteuerung. Die I/O-Kanäle können mit bis zu 24 V betrieben werden und bieten große Eingangs- und Ausgangspuffer. Die Relais-Ausgänge eignen sich für bis zu 2 A, was zur Steuerung von 24V-Bausteinen mit geringer Leistungsaufnahme ausreicht, z. B. für das Magnetventil 81 546 001 von Crouzet.

Für die Softwareentwicklung mit dem Automation-HAT bietet Pimoroni ein passendes Python-Modul, über das die Hardwarefeatures des HAT mit wenigen Codezeilen genutzt werden können. Wenn das Pimoroni-Modul in ein Python-Programm importiert wird, erstellt es Softwareobjekte für die analogen und digitalen Eingänge, den Relaisausgang und die LED-Steuerung, jeweils einschließlich der entsprechen Low-Level-Funktionen für das Lesen und Schreiben (Listing 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)))

Listing 1: Das Python-Modul von Pimoroni für das Automation-HAT von Pimoroni vereinfacht die Entwicklung durch die Behandlung von detaillierten Transaktionen, z. B. Auslesen des Onboard-ADC (Analog-Digital-Wandler). (Bildquelle: Pimoroni)

Jedes Objekt identifiziert den entsprechenden Kanal und weitere zugehörige Daten. Das Objekt für den Analogeingang erhält z. B. beim Erstellen die maximale Spannung am zugeordneten Pin (siehe Funktion "init" in Listing 1). Das ADC-Objekt ruft zur Durchführung einer Analog-Digital-Wandlung das zu Grunde liegende ADC-Modul auf (ads1015.read in Listing 1). Das ADC-Modul führt wiederum die erforderlichen Low-Level-I2C-Transaktionen durch, die zum Einrichten des ADC und zur Durchführung einer Wandlung erforderlich sind, bevor es den Wert in verwendbarer Form zurückgibt (Listing 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

...

Listing 2: Ein Funktionsaufruf auf höherer Ebene für eine ADC-Wandlung ruft eine Leseroutine auf, die einen Schreibvorgang auf dem I2C-Bus ausführt, um die Wandlung zu starten, wartet auf den Abschluss der Wandlung und führt einen Lesevorgang auf dem I2C-Bus durch, um das Ergebnis zu erfassen. (Bildquelle: Pimoroni)

Der Entwickler muss zum Auslesen eines analogen Werts für das analoge Objekt einfach nur eine High-Level-Lesefunktion (.read()) für den angegebenen Analogeingang (.one) ausführen:

          value = automationhat.analog.one.read()

Die Bibliothek unterstützt dieses einfache Modell auch für andere HAT-Funktionen. So ist das Ein- oder Ausschalten eines Relais nur ein einfacher Aufruf:

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

Flexible Optionen

Das Automation-HAT von Pimoroni bietet die für kleine industrielle Automatisierungsanwendungen erforderliche grundlegende I/O-Funktionalität, jedoch können die Endwickler aus einem breiten Spektrum von verfügbaren HATs für alle möglichen Features wählen, die für spezielle Anwendungen, z. B. in der industriellen Automatisierung, benötigt werden. Das RTC-HAT 3013 von Adafruit bietet z. B. die Funktionalität einer Echtzeituhr (RTC). Dies ist keine Standardfunktion der Platine selbst. Die Designer des Raspberry Pi erwarten, dass Entwickler die Verbindung des Boards mit dem Internet aufrechterhalten, wo es das standardmäßige Netzwerkzeitprotokoll NTP (Network Time Protocol) verwenden kann, um die Uhrzeit beizubehalten. Daher ist für Bausteine, deren Internetverbindung absichtlich oder versehentlich abbrechen kann, eine externe Echtzeituhr (RTC) wie das RTC-HAT von Adafruit erforderlich.

Beim Hinzufügen von Funktionen wie RTC, sind die Entwickler bei der Entwicklung eines Bausteins für die industrielle Automatisierung nicht auf ein einziges HAT beschränkt. Auf einem Raspberry Pi können mehrere HATs gestapelt werden. Obwohl für die meisten HATs das Stapeln vorgesehen ist, müssen ggf. Stapel-Steckleisten wie die 2223 von Adafruit oder M2.5-Abstandhalter angebracht werden, um zu verhindern, dass die HATs sich gegenseitig oder die Grundplatine berühren.

Mit Stapel-Steckleisten und Abstandhaltern kann ein HAT wie das Motor-HAT 2348 von Adafruit, das eine für viele industrielle Automatisierungsanwendungen benötigte Motoransteuerung mitbringt, einfach angebracht werden. Ein Motor-HAT 2348 kann zwei Schrittmotoren oder vier Gleichstrommotoren ansteuern. Tatsächlich können bis zu 32 dieser Zusatzplatinen aufeinander gestapelt werden und bis zu 64 Schrittmotoren oder 128 Gleichstrommotoren ansteuern (Abbildung 2).

Bild: Mehrere Motor-HATs 2348 von Adafruit

Abbildung 2: Es können mehrere Motor-HATs 2348 von Adafruit gestapelt werden und bis zu 64 Schrittmotoren oder 128 Gleichstrommotoren ansteuern. (Bildquelle: Adafruit)

Ebenso wie das Automation-HAT von Pimoroni kann das Motor-HAT 2348 von Adafruit mit ein paar einfachen Python-Befehlen programmiert werden. Die Softwarebeispiele von Adafruit für das Motor-HAT veranschaulichen sogar grundlegende Konstruktionsmuster für den Einsatz der Python-Threading-Moduls zur parallelen Ansteuerung mehrerer Motoren (Listing 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()

Listing 3: Das Python-Modul für das Motor-HAT von Adafruit umfasst z. B. dieses Codebeispiel, das den Einsatz einfacher Steuerbefehle und die Verwendung des Python-Threading-Moduls zur gleichzeitigen Steuerung zweier Schrittmotoren demonstriert. (Bildquelle: Adafruit)

Wenn über die verfügbaren HATs hinausgehende Funktionalität benötigt wird, so sind die Entwickler nicht auf das HAT-Format beschränkt. Das Arduino-Shield DFR0327 von DFRobot, das Starter-Kit GrovePi+ von Seeed Technology und das Click-Shield MIKROE-2756 von MikroElektronika eröffnen den Entwicklern den Zugang zu einem breiten Spektrum von Arduino-Shields, Grove-Komponenten und MikroBUS-Click-Boards.

Mit diesen Boards können Entwickler schnell Unterstützung für Standard-CAN-Schnittstellen hinzufügen, indem sie das CAN-Click-Board MIKROE-988 von MikroElektronika einsetzen. Und mit dem Click-Board MIKROE-1296 von MikroElektronika kann Unterstützung für 4 bis 20 mA Stromschleifen hinzugefügt werden.

Abrundung der Konstruktion für kleine Unternehmen

Auch nach der Aufrüstung eines Raspberry Pi-Designs mit der erforderlichen Zusatzfunktionalität verlieren die Entwickler häufig Zeit mit dem Erstellen einer geeigneten Benutzeroberfläche. Beim Raspberry Pi 3 können die Entwickler das Gerät mit dem I/O-Cloud-Dienst von Adafruit verbinden, der eine grafische Oberfläche zum Feedback und zur Steuerung des Automatisierungsprozesses bereitstellt. Der Cloud-Dienst ermöglicht den Entwicklern, einfache Feeds mit Daten- und Prozessinformationen zu erzeugen (Listing 4) und Dashboards zu generieren, die die Überwachung und Steuerung von Projekten von jedem Browser, Desktop-PC, Smartphone oder einem beliebigen Mobilgerät aus erlaubt (Abbildung 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)

Listing 4: Die Entwickler können einfach Daten zur Überwachung und Steuerung von ihrer industriellen Automatisierungsanwendung zur I/O-Cloud von Adafruit streamen. (Bildquelle: Adafruit)

Bild des I/O-Dashboards von Adafruit

Abbildung 3: Die Entwickler können Informationen von ihrer industriellen Automatisierungsanwendung auf Raspberry-Pi-3-Basis anzeigen und diese über das I/O-Dashboard von Adafruit steuern. (Bildquelle: Adafruit)

Diese Kombination von einfacher Softwareentwicklung, verschiedenen Zusatzplatinen und dem äußerst leistungsfähigen Raspberry Pi bietet eine geeignete Lösung für kleinere industrielle Automatisierungsanwendungen. In manchen dieser Anwendungen benötigen die Entwickler möglicherweise eine genauere Zeitsteuerung als die, die von Konfigurationen mit RTC wie dem RTC-HAT 3013 von Adafruit geboten wird.

Das RTC-HAT 3013 basiert auf dem RTC-IC DS3231 von Maxim Integrated. Dieser bietet zwei programmierbare Alarme und ein Rechteckwellen-Ausgangssignal. Die Entwickler können mithilfe der Alarme Interrupts nach einer bestimmten Anzahl von Tagen, Stunden, Minuten und Sekunden generieren oder mithilfe der Rechteckwelle Interrupts mit deren Frequenz von 1 Hz generieren. Für Anwendungen, die periodische Interrupts mit höheren Frequenzen als 1 Hz erfordern, müssen geeignete Softwarefunktionen entwickelt werden, die den Systemzeitgeber des Prozessors einsetzen, oder es müssen spezielle Hardware-Counter eingebaut werden, die den Interrupt mit der gewünschten Häufigkeit generieren.

In Anwendungen, für die eine feinere Zeitauflösung erforderlich ist, wird die Forderung nach einer deterministischen Reaktionslatenz ebenfalls wichtig. Bei sehr hohen Frequenzen könnte die variable Reaktionslatenz des Standard-Raspbian-Betriebssystems die Genauigkeit beeinträchtigen. Zwar liefert das Standardsystem im Millisekundenbereich eine wahrscheinlich ausreichende deterministische Reaktion, aber möglicherweise sind Ansätze wie das Linux PREEMPT_RT-Patch nötig, wenn höhere und deterministischere Auflösungen gefordert sind.

Fazit

Die Fähigkeiten herkömmlicher PLCs liegen normalerweise jenseits des Anforderungen und Budgets kleinerer Industrieunternehmen, die Kleinserien fertigen, bearbeiten und Prototypen herstellen. Bei diesen Anwendungen stehen die Betreiber normalerweise vor bescheideneren Anforderungen, die häufig im Bereich eines Raspberry Pi 3 liegen.

Mit dem Raspberry Pi 3 und geeigneten Zusatzplatinen können schnell dedizierte industrielle Automatisierungssysteme implementiert werden, die die Anforderungen vieler kleiner Werkstätten erfüllen.

Haftungsausschluss: Die Meinungen, Überzeugungen und Standpunkte der verschiedenen Autoren und/oder Forumsteilnehmer dieser Website spiegeln nicht notwendigerweise die Meinungen, Überzeugungen und Standpunkte der Digi-Key Electronics oder offiziellen Politik der Digi-Key Electronics wider.

Über den Verlag

Nordamerikanische Fachredakteure von Digi-Key