Raspberry Pi GPIO How-To

GPIO-Pin's - auch General Purpose Input Output - bilden die zentrale Schnittstelle zwischen dem Raspberry Pi zu externen Geräten und digitalen Schaltungen. Dabei übernehmen bestimmte Pin's neben der einfachen Ansteuerung auch bestimmte Funktionen wie die Kommunikation per I2C, UART oder SPI.


Raspberry Pi GPIO Belegung

WiringPiRev 2Rev 1 Rev 1Rev 2WiringPi
1 2
8GPIO 2GPIO 03 4
9GPIO 3GPIO 15 6
7GPIO 4GPIO 47 8GPIO 14GPIO 1415
9 10GPIO 15GPIO 1516
0GPIO 17GPIO 1711 12GPIO 18GPIO 181
2GPIO 27GPIO 2113 14
3GPIO 22GPIO 2215 16GPIO 23GPIO 234
17 18GPIO 24GPIO 245
12GPIO 10GPIO 1019 20
13GPIO 9GPIO 921 22GPIO 25GPIO 256
14GPIO 11GPIO 1123 24GPIO 8GPIO 810
25 26GPIO 7GPIO 711
 
1 2
17GPIO 28GPIO 283 4GPIO 29GPIO 2918
19GPIO 30GPIO 305 6GPIO 31GPIO 3120
7 8

100 LTE-Tarife im Vergleich

GPIO Export

Variante 1: Export mit der Bash

Bevor man einen Pin ansteuern kann, muss dieser bei jedem Neustart freigeschaltet werden. GPIO's werden auf dem Raspberry Pi und den meisten Mikrocontrollern als Dateien repräsentiert und befinden sich im Ordner /sys/class/gpio.

Zunächst teilen wir dem System unseren zu exportierenden GPIO (z.B. 17) mit.
pi@raspberrypi ~ $ echo "17" > /sys/class/gpio/export
bash: export: Permission denied
Um einen GPIO zu exportieren müssen wir jedoch Root sein (was ein bisschen nervt). Entweder wechselt man vorher zum Root-Benutzer (Passwort: raspberry):
pi@raspberrypi ~ $ su root
oder man ändert die Rechte der export-Datei:
pi@raspberrypi ~ $ sudo chmod 222 /sys/class/gpio/export /sys/class/gpio/unexport
Das GPIO-System hat nun einen neuen Ordner /sys/class/gpio/gpio17/ angelegt mit dem wir arbeiten können. Als letztes definiert man ob man aus dem GPIO lesen (in) oder schreiben (out) will.
pi@raspberrypi ~ $ echo "out" > /sys/class/gpio/gpio17/direction
Nun ist der Pin exportiert und bereit zum ansteuern. Der GPIO selber kann zwei Zustände annehmen. Schreibt man eine "1" nach gpio17/value, so liegen genau 3,3 Volt an. Schreibt man eine "0" hinein, dann fließt natürlich kein Strom mehr.
pi@raspberrypi ~ $ echo "1" > /sys/class/gpio/gpio17/value
Um Alles wieder rückgänigig zu machen, gibt man folgendes ein:
pi@raspberrypi ~ $ echo "17" > /sys/class/gpio/unexport

Variante 2: Export mit WiringPi

WiringPi ist ein hilfreiches Programm zum Export und zur Steuerung von GPIO's. Darüberhinaus kann es mit den mitgelieferten Bibliotheken in C, C++, Python, Java und PHP eingebunden werden.

Da es nicht standardmäßig im Betriebssystem integriert ist, muss es über Git nachinstalliert werden. Falls Git noch nicht installiert ist, müssen folgende Befehle ausgeführt werden:
pi@raspberrypi ~ $ sudo apt-get update
pi@raspberrypi ~ $ sudo apt-get install git-core
Jetzt kann man wiringPi herunterladen und installieren.
pi@raspberrypi ~ $ git clone git://git.drogon.net/wiringPi
pi@raspberrypi ~ $ cd WiringPi
pi@raspberrypi ~/WiringPi $ ./build
Nun exportieren wir wie oben den GPIO 17 mit dem eben installiertem Programm gpio.
pi@raspberrypi ~ $ gpio export 17 out
Und schalten ihn durch.
pi@raspberrypi ~ $ gpio -g write 17 1
Will man dagegen den aktuellen Wert lesen, gibt man folgendes ein.
pi@raspberrypi ~ $ gpio -g read 17
1
WiringPi benutzt eine andere GPIO-Belegung (Tabelle oben). Die Option -g weist WiringPi an, die normale Raspberry Pi Belegung zu benutzen.

Ansteuerung mit C/C++

GPIO schreiben

Als Beispiel lassen wir eine LED die über den Pin 11 (= GPIO 17 = WiringPi Pin 0) und dem Pin 14 (Masse) verbunden ist im Abstand von 100 ms blinken. Die Bibliothek wiringPi.h muss wie im letzten Kaptitel beschrieben, installiert sein.
pi@raspberrypi ~ $ vi gpio_write.cpp
// WiringPi-Api einbinden
#include <wiringPi.h>

// C-Standardbibliothek einbinden
#include <stdio.h>

int main() {

  // Starte die WiringPi-Api (wichtig)
  if (wiringPiSetup() == -1)
    return 1;

  // Schalte GPIO 17 (=WiringPi Pin 0) auf Ausgang
  // Wichtig: Hier wird das WiringPi Layout verwendet (Tabelle oben)
  pinMode(0, OUTPUT);

  // Dauerschleife
  while(1) {
    // LED an
    digitalWrite(0, 1);

    // Warte 100 ms
    delay(100);

    // LED aus
    digitalWrite(0, 0);

    // Warte 100 ms
    delay(100);
  }
}
Nun kompilieren wir das Skript
pi@raspberrypi ~ $ g++ gpio_write.cpp -o gpio_write -lwiringPi
und führen es mit Root-Rechten aus
pi@raspberrypi ~ $ sudo ./gpio_write
Eine detailierte Beschreibung der WiringPi-Api gibts hier.

GPIO lesen

Jetzt erweitern wir das obere Beispiel um einen lesenden GPIO. In unserem Fall prüfen wir den GPIO 24 (= WiringPi-Pin 5) gegen den Pin 17 (3.3V) auf Durchgang und lassen dann die LED blinken. Ist der GPIO durchgeschaltet erhalten wir eine 1, ansonsten eine 0.
Eine Ausnahme beim Raspberry Pi sind hier die GPIO's 2 (Pin 3) und 3 (Pin 5). Da diese Pins für I2C benutzt werden liegen dauerhaft 3.3V an. In der Praxis müssen diese gegen Masse geschaltet werden und signalisieren bei Durchgang eine 0 und bei Unterbrechung eine 1. Weitere Informationen dazu findet ihr hier.
// WiringPi-Api einbinden
#include <wiringPi.h>

// C-Standardbibliothek einbinden
#include <stdio.h>

int main() {

  // Starte die WiringPi-Api (wichtig)
  if (wiringPiSetup() == -1)
    return 1;

  // Schalte GPIO 17 (=WiringPi Pin 0) auf Ausgang
  pinMode(0, OUTPUT);

  // Schalte GPIO 24 (=WiringPi Pin 5) auf Eingang
  pinMode(5, INPUT);

  // Dauerschleife
  while(1) {
    // LED immer ausmachen
    digitalWrite(0, 0);

    // GPIO lesen
    if(digitalRead(5)==1) {
      // LED an
      digitalWrite(0, 1);

      // Warte 100 ms
      delay(100);

      // LED aus
      digitalWrite(0, 0);

      // Warte 100 ms
      delay(100);
    }
  }
}

Ansteuerung mit C#

Um C# auf dem Raspberry Pi zu nutzen muss zuerst die Laufzeitumgebung Mono nachinstalliert werden.
pi@raspberrypi ~ $ sudo apt-get update
pi@raspberrypi ~ $ sudo apt-get install mono-complete
Als nächstes laden wir die RaspberryPiDotNet-Api und kompilieren eine Bibliothek die wir später einbinden können.
pi@raspberrypi ~ $ mkdir gpio_csharp
pi@raspberrypi ~ $ git clone git://github.com/cypherkey/RaspberryPi.Net.git
pi@raspberrypi ~ $ cd RaspberryPi.Net/RaspberryPiDotNet
pi@raspberrypi ~/RaspberryPi.Net/RaspberryPiDotNet$ xbuild RaspberryPiDotNet.csproj
pi@raspberrypi ~/RaspberryPi.Net/RaspberryPiDotNet$ cp bin/Debug/RaspberryPiDotNet.dll /home/pi/gpio_csharp/
Die RaspberryPiDotNet.dll bietet zwei Wege um die GPIO's anzusprechen. Zu einem können diese über die GPIO-Dateien (GPIOFile) oder direkt über den Speicher (GPIOMem) gesteuert werden. Die zweite Methode ist laut Dokumentation wesentlich schneller, braucht jedoch die die kompilierte bcm2835-Bibliothek:
pi@raspberrypi ~ $ wget http://www.open.com.au/mikem/bcm2835/bcm2835-1.3.tar.gz
pi@raspberrypi ~ $ tar -zxf bcm2835-1.3.tar.gz
pi@raspberrypi ~ $ cd bcm2835-1.3
pi@raspberrypi ~/bcm2835-1.3$ ./configure
pi@raspberrypi ~/bcm2835-1.3$ make
pi@raspberrypi ~/bcm2835-1.3$ sudo make check
pi@raspberrypi ~/bcm2835-1.3$ sudo make install
pi@raspberrypi ~/bcm2835-1.3$ cd src
pi@raspberrypi ~/bcm2835-1.3/src$ cc -shared bcm2835.o -o libbcm2835.so
pi@raspberrypi ~/bcm2835-1.3/src$ cp libbcm2835.so /home/pi/gpio_csharp/
Nun kommen wir (endlich) zum eigentlichen Code. Ich habe wie beim oberen Beispiel zwischen dem Pin 11 (GPIO 17) und Pin 14 (Masse) eine LED gehängt. Wird nun der Pin 18 (GPIO 24) und Pin 17 (Masse) überbrückt, so blinkt die LED im 100ms-Takt.
pi@raspberrypi ~/gpio_sharp$ vi gpio.cs
using System;
using RaspberryPiDotNet;

namespace Gpio
{
    class Program
    {
        static void Main(string[] args)
        {
            // GPIO's initialisieren
            GPIOMem gpio17 = new GPIOMem(GPIOPins.V2_GPIO_17);
            GPIOMem gpio24 = new GPIOMem(GPIOPins.V2_GPIO_24);

            while(true)
            {
                // LED immer ausmachen
                gpio17.Write(false);

                // GPIO lesen
                if(gpio24.Read()==true) {
                  // LED an
                  gpio17.Write(true);

                  // Warte 100 ms
                  System.Threading.Thread.Sleep(100);

                  // LED aus
                  gpio17.Write(false);

                  // Warte 100 ms
                  System.Threading.Thread.Sleep(100);
                }
            }
        }
    }
}
Zum Schluss kompilieren wir noch den Code und starten ihn in der 4.0 Runtime (Wichtig)
pi@raspberrypi ~/gpio_sharp$ mcs gpio.cs -r:RaspberryPiDotNet.dll
pi@raspberrypi ~/gpio_sharp$ sudo mono --runtime=v4.0 gpio.exe

Ansteuerung mit Python

Für die Programmierung der GPIO's mithilfe Python muss die Python-Entwicklungsungebung sowie die RPI.GPIO Bibliothek nachinstalliert werden.
pi@raspberrypi ~ $ sudo apt-get update
pi@raspberrypi ~ $ sudo apt-get install python-dev
pi@raspberrypi ~ $ sudo apt-get install python-rpi.gpio
Das folgende Beispiel ist eine Portierung der oberen C/C++/C# Varianten. Sobald Pin 18 (GPIO 24) mit der Masse verbunden wird (z.B: Pin 17), blinkt eine über Pin 11 (GPIO 17) und Pin 14 (Masse) verbundene LED im 100ms Takt.

Info: Die Nummerierung der GPIO's ist gleich der Pinnummerierung
pi@raspberrypi ~/gpio_python$ vi gpio.py
import time
import RPi.GPIO as GPIO

# RPi.GPIO Layout verwenden (wie Pin-Nummern)
GPIO.setmode(GPIO.BOARD)

# Pin 18 (GPIO 24) auf Input setzen
GPIO.setup(18, GPIO.IN)

# Pin 11 (GPIO 17) auf Output setzen
GPIO.setup(11, GPIO.OUT)

# Dauersschleife
while 1:
  # LED immer ausmachen
  GPIO.output(11, GPIO.LOW)

  # GPIO lesen
  if GPIO.input(18) == GPIO.HIGH:
    # LED an
    GPIO.output(11, GPIO.HIGH)

    # Warte 100 ms
    time.sleep(0.1)

    # LED aus
    GPIO.output(11, GPIO.LOW)

    # Warte 100 ms
    time.sleep(0.1)
Nun kann der Code gestartet werden
pi@raspberrypi ~/gpio_python$ sudo python gpio.py
Hat dir dieser Artikel gefallen? Bewerte ihn!
Raspberry Pi GPIO How-To << Raspberry Pi Guide
4.5/5 bei 292 Bewertungen

80 Kommentare


  • Thumbs up schrieb am 15.10.2013 um 22:29 Alle notwendigen Schritte zum Einstieg sind hier bersichtlich und leicht verstndlich auf den Punkt gebracht. Man kann auch 500-Seiten-Spezifikationen lesen; Wer nicht Elektrotechnik studiert hat, ist hier aber definitiv besser aufgehoben. Vielen Dank!
    Antworten Direktlink
  • Bigspid schrieb am 30.7.2015 um 14:32 Auch als Elektrotechnik Absolvent bin ich sehr dankbar für die kurze und übersichtliche Anleitung! Spart einiges an Zeit und Arbeit!
    Antworten Direktlink
  • Huber schrieb am 11.8.2015 um 17:52 Wofür bräuchtest du hier so spezielle Kenntnisse in der ET? ^^
    Antworten Direktlink
  • Martin schrieb am 20.10.2013 um 15:17 Hallo, erstmal super kompliment. Auch ein Windowser kommt hiermit leicht zurecht, wenn, ja wenn alles funzen wrde ^^ Hab mir nach studieren dieser Seite auch ein Pi zugelegt. Er luft und selbst eine RDP Sitzung ber mein Win8.1 Surface klappt. Leider kann ich die RaspberryPiDotNet nicht komplieren.
    Bei xbuild RaspberryPiDotNet.csptoj kommt ein Fehler 'DS1620.cs(94,42): error CS0589 internal compiler errorduring parsing'. Was mach ich falsch?
    Grsse
    Martin
    Antworten Direktlink
  • Vincent.Vega schrieb am 7.3.2014 um 22:02 Die DS1620.cs ließ sich bei mir auch nicht kompilieren... Da in Zeile 94 beim Dividend ja schon explizit als Double gecastet wird, muss man sich keine Sorgen mehr über den Genauigkeitsverlust des Ergebnisses machen, da dieses zwangsläufig auch vom Typ Double sein wird. Das ".0" beim Divisor kann man sich also sparen, tut man dies klapps dann auch mit dem Kopilieren.

    Testen kann man dieses Verhalten auch schön in der Konsole ($ csharp).

    Da dieses Problem nur auftritt wenn man auf dem Pi selber Kompilieren will, vermute ich das es irgendetwas mit dem soft-/hard-Floting-Verhalten zu tun hat.

    Grüße Vince...
    Antworten Direktlink
  • Boris Gaertner schrieb am 7.4.2014 um 17:37 Der Fehler kommt mir bekannt vor. Den hatte ich auch, solange ich Raspbian vollstaendig für Deutsch konfiguriert hatte.

    Der Uebeltaeter ist in der Konfiguration von Raspbian im Konfigurationspunkt "Internationalisation options -> change locals" die Einstellung "Default locale for the system environment" Hier darf *nicht* de_de.UTF8 ausgewaehlt werden. Die Einstellung None ist in Ordnung, britisches oder amerikanisches Englisch würde wohl auch gehen.

    Es scheint, dass der Compiler mcs bei der Konvertierung der Schreibform im Programm stehender Gleitkommazahlen die Einstellung für "Default locale..." berücksichtigt, was er natürlich nicht darf. Programmiersprachen sind vom Gebietsschema unabhängig!

    Beste Grüße
    Boris

    PS. Es ist 15 Jahre her, dass IBM Visual Age for Smalltalk einen ganz ähnlichen Fehler in der Schnittstelle zu SQL hatte. Es werden eben immer wieder die gleichen Fehler gemacht :-)
    Antworten Direktlink
  • Boris Gaertner schrieb am 25.4.2015 um 12:14 Zur Ergänzung:

    Statt

    xbuild RaspberryPiDotNet.csproj

    export LANG=NONE && xbuild RaspberryPiDotNet.csproj

    sollte den Compiler dazu bringen, das eingestellte Gebietsschema zu ignorieren und Gleitkommazahlen richtig zu parsen.
    Antworten Direktlink
  • plipp schrieb am 22.4.2016 um 09:11 Statt auf dem Raspberry zu compilieren,gibt es auch die Möglichkeit des Cross-Compilierens
    http://hackaday.com/2016/02/03/code-craft-cross-compiling-for-the-raspberry-pi/

    PS: Gcc gibts auch für Windows.
    Antworten Direktlink
  • Emanuel schrieb am 26.1.2014 um 23:11 Hallo zusammen,

    ich hab mir mal auch einen Rasperry Pi zugelegt und auch das dazugehörige Raspian installiert. Alles läuft super. Dazu kam ein SSH Server, ein Samba Server und das Mono Complete Paket. Ich muss sagen, ich als Windows only Programmierer bin mit dem Rasperry Pi und dem Raspian sehr gut zurecht gekommen. Natürlich habe ich als Windows Mensch C# verwendet. Die Quelle hab ich auf meinem Windows Laptop (mit VS 2013 und Win 8.1) entwickelt und über den Samba Server auf den Rasperry Pi transportiert. Zur Zeit habe ich eine kleine Lichterorgel laufen mit vier 3,3 Volt LEDs.

    @Martin: Ich weiß nicht was du machst, aber bei mir läufts ohne Probleme.

    Hier mal einen großen Dank an den Schreiber dieser Dokumentation und an die Entwickler des Rasperry Pi.

    Gruß
    Emanuel
    Antworten Direktlink
  • Zodiak schrieb am 31.1.2014 um 12:23 Man merkt das du:

    A. Wenig Erfahrung mit Unixoiden Systemen hast.
    B. Noch weniger Erfahrung über Rechtesystem derselben hast.

    ;)
    Antworten Direktlink
  • RGuide schrieb am 3.2.2014 um 16:42 Oh, Verzeihung. Wie kann ich mir einbilden eine Seite über das Raspberry Pi zu machen
    ohne alle Feinheiten über unixoide Systeme und deren Rechteverwaltung zu wissen.
    Besser ich ich mach gar nichts und schreib unnötige Kommentare...ja, das ist um einiges erfüllender.
    Antworten Direktlink
  • Schlauschiss schrieb am 4.2.2014 um 13:37 mal Ehrlich, hast du nichtmal den Kernel selbst kompilliert und die Inodes auf dem Flash per hand nachgezählt?
    Antworten Direktlink
  • Linuxfreak schrieb am 21.2.2014 um 15:05 Was???!!!??? Ich bin entsetzt! Du hast deinen Kernel etwas nicht selber geschrieben? Wie kannst du es dann wagen, ein Raspberry-Pi-Tutorial zu machen? Schäm dich, ich bin wirklich enttäuscht.

    Aber sonst ein super Tutorial! :)
    Antworten Direktlink
  • mrBobDobalina schrieb am 13.3.2014 um 17:49 Hallo,
    ein sehr schönes Tutorial.
    Nicht nur der Inhalt, auch die Machart.
    Die vielen kl. Konsolenbildchen im Text .. i like.

    Aber ich würde gerne noch ein Bsp. in C sehen wo plain gearbeitet wird.
    Also ohne WiringPI.h
    Antworten Direktlink
  • Dillan schrieb am 16.3.2014 um 02:04 Ja das wäre wirklich super wenn noch ein Beispiel in C ergänzt werden könnte!
    Danke
    Antworten Direktlink
  • mrBobDobalina schrieb am 21.3.2014 um 04:09 Ich hab mir eine kl. Headerdatei in C geschrieben. Mit gcc auf raspbian compiliert.
    Ich nutz sie nur für Ausgangsschaltungen (zB LED, Beeper, einzelne Pins etc).
    Im BspCode schaltet GPIO17 für 5 sec an (3,3V).

    GPIO.h:
    /*=============================================================
    * General Purpose Input/Output (GPIO) Management
    * for the RaspberryPI Model B Revision 1
    *
    * GPIOCtrl(..) - GPIO Management
    * GPIO(..) - GPIO Pin ON/OFF
    * =============================================================

    #include
    #include
    #include

    enum{OFF, ON};
    enum{OUT, IN};
    enum{EXPORT, UNEXPORT, DIRECTION, VALUE};

    char cGPIOPath[30] = {""};

    char * GPIOPath(int cMode, char * cGPIONumber)
    {
    memset(cGPIOPath, 0, sizeof(cGPIOPath));
    strcat(cGPIOPath, "/sys/class/gpio");

    switch(cMode)
    {
    case EXPORT:
    {
    strcat(cGPIOPath, "/export");
    break;
    }
    case UNEXPORT:
    {
    strcat(cGPIOPath, "/unexport");
    break;
    }
    case DIRECTION:
    {
    strcat(cGPIOPath, "/gpio");
    strcat(cGPIOPath, cGPIONumber);
    strcat(cGPIOPath, "/direction");
    break;
    }
    case VALUE:
    {
    strcat(cGPIOPath, "/gpio");
    strcat(cGPIOPath, cGPIONumber);
    strcat(cGPIOPath, "/value");
    break;
    }
    }
    return cGPIOPath;
    }

    ==============================
    test.c:

    #include
    #include
    #include "GPIO.h"

    int main(int argc, char** argv)
    {
    printf("Create GPIO Port\n");
    GPIOCtrl(true, "17", OUT);

    printf("sleep..\n");
    sleep(5);

    printf("Switch ON\n");
    GPIO("17", ON);

    printf("sleep..\n");
    sleep(5);

    printf("Switch OFF\n");
    GPIO("17", OFF);

    printf("Remove GPIO Port\n");
    GPIOCtrl(false, "17", 0);

    return 0;
    }

    Wenn man das Programm nicht als root laufen lassen möchte dann vorher natürlich Rechte anpassen:
    sudo chmod 222 /sys/class/gpio/export /sys/class/gpio/unexport
    Antworten Direktlink
  • MrBob schrieb am 21.3.2014 um 04:17 Hallo ... Admin
    kannst du diese Posts (quellcode) bitte löschen?
    ich kann den code hier nicht korrekt hochladen.
    da immer etwas fehlt wird es so leider nicht laufen :(

    merci
    Antworten Direktlink
  • MrBobDobalina schrieb am 21.3.2014 um 04:12 Sehe gerade ich kann keine TagZeichen setzen daher ergänzend:

    GPIO.h:
    #include stdbool.h
    #include string.h
    #include fcntl.h

    test.c
    #include stdio.h
    #include unistd.h
    #include "GPIO.h"
    Antworten Direktlink
  • Ralph schrieb am 14.5.2014 um 15:41 Servus Leute, ich hab auch eine Frage an euch:
    Ich versuche mit meinem Raspi einen Monochrom Rit-Display anzusteuern:
    Panel resolution : 64*64
    ‐ Driver IC : SSD1305
    ‐ Excellent Quick response time : 10μs
    ‐ Extremely thin thickness for best mechanism design : 1.41 mm
    ‐ High contrast : 2000:1
    ‐ Wide viewing angle : 160
    ‐ Strong environmental resistance.
    ‐ 8-bit 6800-series Parallel Interface, 8-bit 8080-series Parallel Interface,
    Serial Peripheral Interface and I2C Interface.

    Da ich ein totaler Anfänger bin, hab ich mich im Internet nach einer fertigen Lösung in c oder c++ aumgeschaut, leider ohne Erfolg. Kann mir irgendjemand dabei helfen, da ich grad echt kurz vor Verzweiflung bin...
    Vielen Dank
    Antworten Direktlink
  • Little Basterd schrieb am 20.7.2014 um 20:45 Zunächst mal ein großes Kompliment für die Seite. Es steckt unwahrscheinlich viel Information drin, die Anfänger und erfahrenere User weiter bringt.
    Mir kommt Python etwas zu kurz, weil das sozusagen die Muttersprache des Raspi ist und weil Python die GPIO-Steuerung am transparentesten macht.
    Antworten Direktlink
  • Mathias schrieb am 7.8.2014 um 12:42 Hallo Leute,

    bei xbuild RaspberryPiDotNet.csptoj kommt ein Fehler 'DS1620.cs(94,42): error CS2001: Source file PinState.cs could not be found

    Antworten Direktlink
  • Manuel schrieb am 18.8.2014 um 21:43 Hallo Matthias

    Ich habe das gleiche Problem mit dem PinState.cs. Hast du schon eine Lösung dafür gefunden.

    Antworten Direktlink
  • Mathias schrieb am 7.8.2014 um 12:44 ups, ich meine nur error CS2001: Source file PinState.cs could not be found
    Antworten Direktlink
  • Bernd schrieb am 8.8.2014 um 11:42 Hallo zusammen,
    habe am Raspi eine 8-Relaismodul von Sainsmart. Wenn ich den Raspi einschalte hat GPIO27 bereits Spannung, heißt ein Relais ist bereits eingeschalten.
    Warum hat dieser Pin Spannung, wie kann ich das ändern?
    Antworten Direktlink
  • PIrat schrieb am 22.8.2014 um 17:51 hallo zusammen
    icha
    habe das programm im lx terminal unter python geschrieben wie kann ich dieses speichern?
    so das ich es später wider aufrufen kann?

    vielen dank
    Antworten Direktlink
  • Dalyan schrieb am 28.8.2014 um 08:23 Hier hat sich ein Fehler eingeschlichen:
    Variante 2: Export mit WiringPi

    pi@raspberrypi ~ $ git clone git://git.drogon.net/wiringPi
    pi@raspberrypi ~ $ cd WiringPi
    pi@raspberrypi ~/WiringPi $ ./build

    die mittlere Zeile müsste heissen:
    pi@raspberrypi ~ $ cd wiringPi (GrossKlein-Schreibung...)

    sonst super!!

    Gruss
    Antworten Direktlink
  • Bender schrieb am 2.9.2014 um 10:07 Hi zusammen,

    finde das Tutorial auch super! :-)
    Leider bleib ich beim C-Kompelieren immer hängen, mit folgender Fehlermeldung:
    g++: error: unrecognized option '-1wiringPi'

    Leider liefert Dr. Google auch keine Lösungshinweise :-/
    Und ich bin auch kein Linuxguru (ja ich hab auch noch keinen Kernel selbst programmiert! ;-) )

    Danke im Voraus

    Gruß
    Bender
    Antworten Direktlink
  • Bender schrieb am 2.9.2014 um 13:02 Fehler gefunden:

    Man macht aus dem 1 ein l und schon klappt es.

    Eieieieieieiei....
    Antworten Direktlink
  • Tony schrieb am 30.9.2014 um 17:50 Die Pinbelegung für den neuen Banana Pi sieht ähnlich aus! Hier haben wir mal alle Pins zusammengetragen: http://www.bananapi-kaufen.de/aufbau-und-pindefinitionen/
    Antworten Direktlink
  • Ich einfach Dumm schrieb am 6.10.2014 um 16:31 Hallo
    Kannst du bei:
    Ansteuerung mit C/C++
    den Befehl "vi gpio_write.cpp"
    nicht in "nano gpio_write.cpp" ändern?
    So hätten User,ohne Linx erfahrung auch ne Chance in die Raspberrywelt
    einzutauchen.

    MfG
    Ich einfach Dumm
    Antworten Direktlink
  • Thilbert schrieb am 15.12.2014 um 15:19 Vielen Dank fuer das Tutorial erstmal, ist mir eine große Hilfe!

    Dir ist allerdings ein kleiner Tippfehler unterlaufen im Punkt 2. beim Export mit WiringPi,
    dort hast du nachdem inkludieren der Wirinpi App
    cd WiringPi anfangs mit Großbuchstaben geschrieben, nach langer sucherei ist mir der Tippfehler erst aufgefallen.

    Weiter so &
    Liebe Grueße Thilbert
    Antworten Direktlink
  • Timo Schneider schrieb am 5.1.2015 um 07:37 Hallo und ein frohes neues Jahr euch allen. Kennt von euch jemand eine Möglichkeit die GPIOs via Interrupt abzufragen (C#)?

    Vielen Dank euch schonmal

    Gruß

    Timo
    Antworten Direktlink
  • Leyliner schrieb am 12.1.2015 um 18:00 Ich bekomme, wenn ich genau nach der Anleitung für C# vorgehe immer eine Fehlermeldung beim Compilieren des Projekts.

    pi@raspberrypi ~/RaspberryPi.Net/RaspberryPiDotNet$ xbuild RaspberryPiDotNet.csproj
    Antworten Direktlink
  • Alex schrieb am 10.2.2015 um 00:43 Hi,

    ich konnte es kompilieren, wenn ich VORHER Folgendes in der Shell ausführe:

    unset LANG

    Antworten Direktlink
  • Felli schrieb am 4.3.2015 um 11:18 Man muss kein root haben um auf die GPIOs zu zugreifen (zumindest nicht meinem Build) die beiden Dateien export und unexport gehören der Gruppe "gpio". Sollte der aktuelle Benutzer vermutlich "pi" nicht dieser Gruppe angehören, reicht folgendes:
    sudo usermod -aG gpio pi
    Im aktuellen Rasbian ist das allerdings schon geschehen.
    Antworten Direktlink
  • Ark26 schrieb am 15.4.2015 um 09:53 Das ist wirklich mal ein super Tutorial.
    Leider habe ich noch ein Problem. Beim Pi2 möchte ich wPin 1,4,5 als Schalter nutzen. Hierzu würde ich sie gern gegen Masse ziehen. wPin 4 funktioniert super da er auf Eingang( logisch 1) steht. Da jedoch leider wPin 1 und 5 Low sind (Eingang gesetzt sind sie auch) können nicht funktionieren. Wie kann ich einen Eingang auf "high" setzen??
    Gern nehme ich auch Tips wegen der der Pull_down Beschaltung entgegen ;). Ich mag mein Spielzeug ja.
    Antworten Direktlink
  • Lenny schrieb am 3.5.2015 um 16:22 Hi, ich habe deinen C++ Code versucht in Codeblocks ein zu geben, dieser meckert aber wegen der Zeile bzw der Funktion "if (wiringPiSetup() == -1)" rum (also wegen wiringPiSetup()). Finde da einfach keine Lösung für, kann mir da wer helfen?
    Antworten Direktlink
  • Ralf schrieb am 20.10.2015 um 14:26 Du musst dem Linker wiringPI mitgeben. Auf der Komandozeile wäre das -l wiringPi. Mit codeblocks gehts du zu Project -> Build Options. Dort dann bei Linker Options wiringPi eintragen. Sollte dann funktionieren.
    Und nicht vergessen bei codeblocks: dann das Projekt speichern sonst ist die linkereintragung beim nächsten start wieder weg.
    Antworten Direktlink
  • Hans-Peter schrieb am 14.5.2015 um 12:51 Hallo Leute,
    Ich habe leider nur Java-Knowledge, wie würde der Programmcode für Java aussehen? Wäre sehr dankbar, wenn ihr mir helfen würdet.
    Antworten Direktlink
  • SoulSurfer schrieb am 25.5.2015 um 22:42 Moin Hans-Peter,

    für Java musst Du "FileWriter" und "FileReader" benutzen. Sofern Du das Javaprogramm nicht als Root ausführst, musst Du die Dateirechte entsprechend setzen (siehe oben bei "sudo chown ...")

    Es empfiehlt sich eine Konstante zu definieren:
    final String GPIO_PATH = "/sys/class/gpio/";

    // Beispiel: Port gpio4 einschalten
    FileWriter fw = new FileWriter( GPIO_PATH + "gpio4/value");
    fw.write( "1" );
    fw.close();

    // Beispiel: Port gpio4 ausschalten
    FileWriter fw = new FileWriter( GPIO_PATH + "gpio4/value");
    fw.write( "0" );
    fw.close();

    // Beispiel: Port gpio4 einschalten
    FileWriter fw = new FileWriter( GPIO_PATH + "gpio4/value");
    fw.write( "1" );
    fw.close();

    // Beispiel: Port gpio4 einlesen (ergibt "0" oder "1")
    String result = "";
    byte[] bytes = new byte[16];
    FileInputStream fr = new FileInputStream( GPIO_PATH + exportPath );
    try {
    int len = fr.read( bytes, 0, bytes.length );
    fr.close();
    result = new String( bytes, 0, len );
    }
    catch (IOException e) {
    System.err.println( e.toString() );
    }
    Antworten Direktlink
  • Danke (nicht-sehr-kreative-ich-weiss-Name) schrieb am 25.6.2015 um 15:29 Danke,
    einfache Lösung, vertraute Sprache :)
    Antworten Direktlink
  • Enigma schrieb am 1.6.2015 um 14:08 Hallo,

    habe mal versucht das C-Programm "GPIO lesen" mit dem Programm Code::Blocks umzusetzen.
    Leider kommen bei mir einige Fehlermeldungen: undefined references delay
    Das selbe auch mit den anderen Funktionenen, wie z.B. digitalWrite oder digitalRead.
    Bin leider noch sehr unerfahren...

    Aber sonst ein wirklich super Tutorial, dass mir schon sehr geholfen hat.
    Antworten Direktlink
  • Enigma schrieb am 2.6.2015 um 09:26 OK,
    anscheinend wurde lwiringPI nicht installiert.
    Wie kann ich denn explizit das installieren?
    Schon mal vilen Dank.
    Antworten Direktlink
  • Viktor schrieb am 30.6.2015 um 09:57 Hallo ich möchte wie oben Beschrieben

    xbuild RaspberryPiDotNet.csproj

    ausführen ! bekomme aber: bash xbuild nicht gefunden

    wer hat noch so ein Problem ???
    Antworten Direktlink
  • Alex schrieb am 17.7.2015 um 16:14 Hi,

    ich möchte mittels c# und der monodevelop-entwicklungsumgebung ein paar gpio`s auf dem raspi ansprechen...

    mit c# hab ich ein klein wenig erfahrung(weshalb ich mich auch für mono entschlossen habe) --> so weit so gut...mono installiert und läuft!

    danach hab ich wirklich alles so installiert wie oben beschrieben! (habe auch wirklich alles auf rechtschreibfehler etc überprüft)

    Jetzt das Problem...als ich den code fertig hatte und kompilieren wollte, kam der Fehler : "The type or namespace name ´RaspberryPiDotNet`could not be found. Are you missing an assembly reference? (CS0246)

    Ich hab in Linux nicht wirklich eine ahnung! Kann mir da vllt einer helfen, wäre echt klasse! Die dll hab ich eigentlich auch im Projektordner... ist da was bei der installation schief gegangen?

    vielen dank
    Antworten Direktlink
  • Dr.Dish schrieb am 26.8.2015 um 11:42 Hier wird mal leicht verständlich für den Anfänger alles wichtige beschrieben. Danke
    Antworten Direktlink
  • Finn schrieb am 3.10.2015 um 15:05 Hey, danke erstmal für das Tutorial.
    Ich habe aber leider ein Problem, nämlich wenn ich den Befehl
    echo "1" > /sys/class/gpio/gpio17/value
    ausführe, kommt zwar keine Fehlermeldung, aber mein daran angeschlossener Motor geht nicht an. Habe ihn auch schon an den Power- und Ground-pin angeschlossen und es hat funktioniert.
    Kann mir jemand helfen?
    Würde mich sehr freuen, LG Finn
    Antworten Direktlink
  • Finn schrieb am 3.10.2015 um 15:07 P.S. kenne mich mit dem Thema echt nicht gut aus :P
    Antworten Direktlink
  • ZufälligVorbeiSurfer schrieb am 12.10.2015 um 21:59 Motor direkt am GPIO??? Die GPIO-Pins können nur wenige mA liefern. Das reicht gerade so für eine (moderne) LED. Wenn man einen größeren Verbraucher anschließt, dann passiert bestenfalls gar nichts. Mit nicht geringer Wahrscheinlichkeit aber verabschiedet sich der komplette Pi mit einem Rauchwölkchen im Nirwana...
    Daher: Größere Verbaucher NIE direkt an die GPIOs hängen, sondern IMMER eine Ansteuerschaltung oder Verstärker oder Ähnliches dazwischen schalten!
    Antworten Direktlink
  • Finn schrieb am 18.10.2015 um 12:33 Oh, ok :D
    Gut zu wissen, danke!
    Antworten Direktlink
  • Phill schrieb am 3.10.2015 um 18:31 Hammer Tutorial, definitiv.
    Habe aber dennoch eine Frage offen.
    Ich bin ein Fan von CSharp und möchte die Pins über den Speicher ansteuern.
    Und ich bin mir Unsicher ob ich die Pins dann dennoch Freischalten muss. Bin recht neu in der Materie und würde mich über eine Kurze und Informative antwort sehr freuen :)
    Antworten Direktlink
  • gerd schrieb am 6.1.2016 um 21:56 "unsicher" und "freischalten" schreibt man klein! :)
    Antworten Direktlink
  • gerd schrieb am 6.1.2016 um 22:00 "kurze" und "informative" schreibt man klein, "Antwort" schreibt man groß. Lernt man das heute nicht mehr in der Schule?
    Antworten Direktlink
  • Milan schrieb am 8.11.2015 um 17:19 Super Einleitung in GPIO-PIN-Programmierung, danke. Aber ich will einen Schritt weiter gehen und muss einen "kontinuierlichen", d. h. synchronen, Datenstrom erzeugen, also sozusagen "harte Echtzeitanforderungen" einhalten.

    Ich möchte gern eine Art Effektgerät für elektronische Musikinstrumente auf dem Raspi realisieren, also z.B. Klangquelle (Keyboard) am A/D-Umsetzer an SPI-Schnittstelle, Signal in Echtzeit bearbeiten ("drauf-rumrechnen") und dann an D/A-Umsetzer an SPI wieder ausgeben.

    Das muss natürlich sauber getaktet werden mit der gewählten Abtastrate. Auf einem DSP würde ich jetzt (in ASSEMBLER) die Interruptvektor-Tabelle erstellen und eine zugehörige Interrupt Service Routine (ISR) erstellen. Der A/D-Umsetzer soll den Takt liefern. Ich weiß, dass der ARM des Raspi auch (natürlich) Interrupts verarbeiten kann.

    Weiß jemand wie das in C realisiert wird? Hat jemand eine alternative Idee, den synchronen Datenstrom aufrecht zu erhalten? Braucht man eine Echtzeiterweiterung wie das XENOMAI etc.? Wie kann man gezielt die Gleitkommaeinheit ansprechen?

    Über Tipps, Beipiele, Quellcodeabschnitte oder auch einfach Links für die eigene Recherche würde ich mich freuen. Habt Dank.

    Antworten Direktlink
  • joe schrieb am 15.11.2015 um 14:23 Hallo und Danke für die Anleitung. Aber wie kann ich das Blinken der LED wieder anhalten?
    Antworten Direktlink
  • Rafael schrieb am 8.12.2015 um 19:34 Hallo zusammen,

    danke für die Einführung.
    Allerdings ist bei dem Pythonteil ein Fehler drin. Dort steht, dass man Pin 18 mit Masse verbinden soll (z.B. Pin17) Das ist aber falsch. Pin17 ist 3.3V Versorgung und nicht Masse. Also nicht verwirren lassen, es soll 3.3V heißen und nicht Masse.
    Wenn man Pin18 mit Masse verbindet wird es nicht funktionieren.

    Gruß
    Antworten Direktlink
  • M. schrieb am 10.12.2015 um 12:26 Muss man eigentlich den GPIO Export auch machen, wenn man nut Python benutzt, oder reicht es, wenn man die python-rpi.gpio installiert?

    Die Anleitung ist super, ohne Schnick-Schnack, leicht verständlich!
    Antworten Direktlink
  • R. schrieb am 10.12.2015 um 12:58 Nee, denke nicht, dass Du das dann auch machen musst. Also ich habe es nicht gemacht und alles hat funktioniert. Ich glaube, dass musst du nur machen, wenn Du die GPIOs über die Bash oder wiringPi ansprechen willst.

    Antworten Direktlink
  • M. schrieb am 10.12.2015 um 14:29 @R. Danke. Hab's grade mal probiert. Komme im Moment nicht physikalisch an den Raspberry. Aber folgendes Programm liefert die richtige Ausgabe.

    import RPi.GPIO as GPIO
    GPIO.setmode(GPIO.BOARD)
    pins = [7,8,10,11,12,13,15,16,18,19,21,22,23,24,26]
    for i in pins:
    if i % 2: #Pinnummer ist ungerade
    GPIO.setup(i, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)
    else:
    GPIO.setup(i, GPIO.IN, pull_up_down = GPIO.PUD_UP)
    if GPIO.input(i) == GPIO.HIGH:
    print str(i) + " = HIGH"
    else:
    print str(i) + " = LOW"
    GPIO.cleanup()


    Ausgabe:

    7 = LOW
    8 = HIGH
    10 = HIGH
    11 = LOW
    12 = HIGH
    13 = LOW
    15 = LOW
    16 = HIGH
    18 = HIGH
    19 = LOW
    21 = LOW
    22 = HIGH
    23 = LOW
    24 = HIGH
    26 = HIGH
    Antworten Direktlink
  • MrBeam schrieb am 11.12.2015 um 16:33 Vielen Dank für diese tolle Anleitung!

    Die Erklärung für die verschiedenen Zählvarianten der GPIO-Nummern fand ich besonders erhellend. Dank des Pythonbeispiels konnte ich meinen Morsecodegenerator endlich um eine physische Ausgabe erweitern :)

    Für alle, die wie ich eine neuere Version des Pis benutzen, habe ich hier noch eine URL zum GPIO Layout für den B+.
    http://pi4j.com/pins/model-b-plus.html
    Antworten Direktlink
  • Sven schrieb am 19.12.2015 um 20:36 Bitte mal den C# Teil aktualisieren für Raspberry Pi 2.

    Dort wird eine aktuellere Version der libbcm benötigt - wohl 1.39 oder größer. Habe selber gerade die aktuellste 1.48 genommen und dann blinkt das Lämpchen :)

    Gibt es unter http://www.airspayce.com/mikem/bcm2835
    Antworten Direktlink
  • DDD schrieb am 5.1.2016 um 11:34 Super Tutorial!!

    Aber bei "Pin's" für den Plural eines Pin, bekomme ich eine Gänsehaut! -.-
    Antworten Direktlink
  • DDD schrieb am 5.1.2016 um 11:37 ...genauso wie bei "GPIO's"!

    Das Plural-s wird OHNE Hochkomma hinten an das Singular angefügt.
    Antworten Direktlink
  • tristans unterdurchnitlicher penis schrieb am 12.1.2016 um 10:41 er hat nen kleienn
    Antworten Direktlink
  • bass schrieb am 13.1.2016 um 13:38 Hallo bei mir lassen sich unter c# die Pin's nicht beschreiben (High oder Low) gpio17 ist immer low
    Antworten Direktlink
  • bass schrieb am 13.1.2016 um 15:04 Ok den vorherigen Fehler habe ich behoben aber wieso kann man die PinDirection nicht auf In umstellen?
    Antworten Direktlink
  • Alex schrieb am 8.2.2016 um 19:46 Hallo,

    vielleicht kann mir jemand helfen?
    Ich habe die C# Anleitung umgesetzt, doch es passiert einfach keine Veränderung an den In-/Outputs :(


    using System;
    using RaspberryPiDotNet;

    namespace GPIOC
    {
    class MainClass
    {
    public static void Main (string[] args)
    {

    GPIOMem gpio17 = new GPIOMem(GPIOPins.V2_GPIO_17);
    Console.WriteLine ("Hello World!");
    while(true)
    {

    gpio17.Write(true);
    Console.WriteLine (gpio17.Read ());

    System.Threading.Thread.Sleep(2000);

    gpio17.Write(false);
    Console.WriteLine (gpio17.Read ());
    }
    }
    }
    }
    Antworten Direktlink
  • mozart schrieb am 11.2.2016 um 13:02 hallo,
    ich habe noch nicht viel Erfahrung mit dem Raspi. Will mit den Raspberry Zero 20 LED's ansteuern. Kann mir hier jemand knapp sagen, was ich an Material brauche und wie die Pins angesteuert werden ? (weil die GPIO's ja unterschiedlich angesteurt werden)
    Antworten Direktlink
  • Andreas schrieb am 2.3.2016 um 21:39 @Felli

    sudo usermod -aG gpio pi

    reicht alleine nicht aus. Es fehlt noch

    newgrp gpio

    damit für den aktuellen eingeloggten Benutzer die Gruppe aktiv wird oder ein logout gefolgt von einem login.
    Antworten Direktlink
  • David schrieb am 3.3.2016 um 08:23 Servus!
    Danke für den leichen Einstieg! Klappt bestens :)
    Jetzt habe ich aber eine Frage.
    Ich will das wiringPi in ein anderes Projekt einbinden, damit ich verschiedene Modi mit LED anzeigen kann.
    Habe einfach in meinem Makefile dsa -lwiringPi zu den Flags hinzugefügt. Bekommme aber dann den Fehler:

    /usr/bin/ld: cannot find -lwiringPi

    Wenn ich aber zb das Blink.c in mein Makefile mitaufnehme klappt das compilen.
    Ich habe bereits eine -L Flag, die auf eine andere Bibliothek linkt.

    Irgendeine Lösung?
    Danke
    Antworten Direktlink
  • molsondry schrieb am 5.3.2016 um 02:48 Hallo zusammen,
    hier noch ein lauffähiges Beispiel in C ohne wiringPI. Man braucht zwei Dateien: GPIO.h und led-blink_c.c


    /******************************************************
    * GPIO.h
    * General Purpose Input/Output (GPIO) Management
    * for the RaspberryPI Model B Revision 1 and 2
    * Functions:
    * char * getGPIOPath(int cMode, char * cGPIONumber)
    * void GPIO(char* portId, int state)
    * void GPIOCtrl(_Bool active, char* portId, int direction)
    * *****************************************************/

    #include
    #include
    #include


    enum{OFF, ON}; //value
    enum{OUT, IN}; //direction
    enum{EXPORT, UNEXPORT, DIRECTION, VALUE};

    char cGPIOPath[30] = {""};

    char * getGPIOPath(int cMode, char * cGPIONumber){
    //Assemble the linux file system path for GPIO configuration

    memset(cGPIOPath, 0, sizeof(cGPIOPath));
    strcat(cGPIOPath, "/sys/class/gpio");

    switch(cMode)
    {
    case EXPORT:
    {
    strcat(cGPIOPath, "/export");
    break;
    }
    case UNEXPORT:
    {
    strcat(cGPIOPath, "/unexport");
    break;
    }
    case DIRECTION:
    {
    strcat(cGPIOPath, "/gpio");
    strcat(cGPIOPath, cGPIONumber);
    strcat(cGPIOPath, "/direction");
    break;
    }
    case VALUE:
    {
    strcat(cGPIOPath, "/gpio");
    strcat(cGPIOPath, cGPIONumber);
    strcat(cGPIOPath, "/value");
    break;
    }
    }
    return cGPIOPath;
    }
    void GPIO(char* portId, int state){
    //Switch a port on or off_type

    FILE *f = fopen(getGPIOPath(VALUE, portId), "w");
    if (f == NULL)
    {
    printf("GPIO() - Error opening file!\n");
    exit(1);
    }
    switch (state) {
    case ON:{
    fprintf(f, "%i", ON);

    }
    case OFF:{
    fprintf(f, "%i", OFF);

    }
    }

    fclose(f);
    } //end void GPIO(char* portId, int state)

    void GPIOCtrl(_Bool active, char* portId, int direction) {
    //Activate/ deactivate a port and set direction (in or out)
    char* sDirection;
    FILE *f;

    if (active){
    //First activate GPIO (export)
    f = fopen(getGPIOPath(EXPORT, portId), "w");
    if (f == NULL)
    {
    printf("GPIOCtrl - Activate GPIO - Error opening file!\n");
    exit(1);
    }

    fprintf(f, "%s", portId);
    fclose(f);

    //Now set direction of GPIO (in or out)
    f = fopen(getGPIOPath(DIRECTION, portId), "w");
    if (f == NULL)
    {
    printf("GPIOCtrl - Set direction GPIO - Error opening file!\n");
    exit(1);
    }
    if(direction==OUT) sDirection="out"; else sDirection="in";
    fprintf(f,"%s",sDirection);
    fclose(f);
    }
    else {//not active, close GPIO
    f = fopen(getGPIOPath(UNEXPORT, portId), "w");
    if (f == NULL)
    {
    printf("GPIOCtrl - not active - Error opening file!\n");
    exit(1);
    }
    fprintf(f, "%s", portId);
    fclose(f);
    }

    }//end GPIOCtrl()


    //end GPIO.h


    /*******************************************
    * led-blink_c.c
    *
    *******************************************/

    #include
    #include
    #include
    #include "GPIO.h"

    void GPIO(char*, int);
    void GPIOCtrl(_Bool, char*, int);

    int main(int argc, char** argv)
    {
    int i;
    printf("Create GPIO Port\n");
    GPIOCtrl(true, "23", OUT);
    GPIO("23", ON);

    for (i=1;i
    Antworten Direktlink
  • molsondry schrieb am 5.3.2016 um 02:54 Leider funktioniert in diesem Forum immer noch nicht das "
    Antworten Direktlink
  • molsondry schrieb am 5.3.2016 um 02:57 Leider funktioniert in diesem Forum immer noch nicht das "<"Zeichen
    Antworten Direktlink
  • molsondry schrieb am 5.3.2016 um 03:01 /******************************************************
    * GPIO.h
    * General Purpose Input/Output (GPIO) Management
    * for the RaspberryPI Model B Revision 1 and 2
    * Functions:
    * char * getGPIOPath(int cMode, char * cGPIONumber)
    * void GPIO(char* portId, int state)
    * void GPIOCtrl(_Bool active, char* portId, int direction)
    * *****************************************************/

    #include <stdbool.h>
    #include <string.h>
    #include <fcntl.h>


    enum{OFF, ON}; //value
    enum{OUT, IN}; //direction
    enum{EXPORT, UNEXPORT, DIRECTION, VALUE};

    char cGPIOPath[30] = {""};

    char * getGPIOPath(int cMode, char * cGPIONumber){
    //Assemble the linux file system path for GPIO configuration

    memset(cGPIOPath, 0, sizeof(cGPIOPath));
    strcat(cGPIOPath, "/sys/class/gpio");

    switch(cMode)
    {
    case EXPORT:
    {
    strcat(cGPIOPath, "/export");
    break;
    }
    case UNEXPORT:
    {
    strcat(cGPIOPath, "/unexport");
    break;
    }
    case DIRECTION:
    {
    strcat(cGPIOPath, "/gpio");
    strcat(cGPIOPath, cGPIONumber);
    strcat(cGPIOPath, "/direction");
    break;
    }
    case VALUE:
    {
    strcat(cGPIOPath, "/gpio");
    strcat(cGPIOPath, cGPIONumber);
    strcat(cGPIOPath, "/value");
    break;
    }
    }
    return cGPIOPath;
    }
    void GPIO(char* portId, int state){
    //Switch a port on or off_type

    FILE *f = fopen(getGPIOPath(VALUE, portId), "w");
    if (f == NULL)
    {
    printf("GPIO() - Error opening file!\n");
    exit(1);
    }
    switch (state) {
    case ON:{
    fprintf(f, "%i", ON);

    }
    case OFF:{
    fprintf(f, "%i", OFF);

    }
    }

    fclose(f);
    } //end void GPIO(char* portId, int state)

    void GPIOCtrl(_Bool active, char* portId, int direction) {
    //Activate/ deactivate a port and set direction (in or out)
    char* sDirection;
    FILE *f;

    if (active){
    //First activate GPIO (export)
    f = fopen(getGPIOPath(EXPORT, portId), "w");
    if (f == NULL)
    {
    printf("GPIOCtrl - Activate GPIO - Error opening file!\n");
    exit(1);
    }

    fprintf(f, "%s", portId);
    fclose(f);

    //Now set direction of GPIO (in or out)
    f = fopen(getGPIOPath(DIRECTION, portId), "w");
    if (f == NULL)
    {
    printf("GPIOCtrl - Set direction GPIO - Error opening file!\n");
    exit(1);
    }
    if(direction==OUT) sDirection="out"; else sDirection="in";
    fprintf(f,"%s",sDirection);
    fclose(f);
    }
    else {//not active, close GPIO
    f = fopen(getGPIOPath(UNEXPORT, portId), "w");
    if (f == NULL)
    {
    printf("GPIOCtrl - not active - Error opening file!\n");
    exit(1);
    }
    fprintf(f, "%s", portId);
    fclose(f);
    }

    }//end GPIOCtrl()


    //end GPIO.h

    /*******************************************
    * led-blink_c.c
    *
    *******************************************/

    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include "GPIO.h"

    void GPIO(char*, int);
    void GPIOCtrl(_Bool, char*, int);

    int main(int argc, char** argv)
    {
    int i;
    printf("Create GPIO Port\n");
    GPIOCtrl(true, "23", OUT);
    GPIO("23", ON);

    for (i=1;i <= 10;i++){

    printf("Switch ON\n");
    GPIO("23", OFF);

    printf("sleep..\n");
    sleep(1);

    printf("Switch OFF\n");
    GPIO("23", ON);

    printf("sleep..\n");
    sleep(1);
    }

    printf("Remove GPIO Port\n");
    GPIOCtrl(false, "23", 0);

    return 0;
    }

    Antworten Direktlink
  • Manfred schrieb am 3.4.2016 um 19:32 Sehr gute Einführung für Anfänger wie mich! Danke!

    Einen Fehler habe ich festgestllt:
    Das Kommando "pi@raspberrypi ~ $ cd WiringPi" führt zu einer Fehlermeldung. Richtig ist "pi@raspberrypi ~ $ cd wiringPi" (wiringPi mit kleinem "w")


    Ergänzende Hinweise:
    1.
    Nach dem Kapitel "Variante 2: Export mit WiringPi" muss der Port noch frei gegeben werden.
    "pi@raspberrypi ~ $ gpio unexport 17"

    2.
    Auf deutscher Tastatur ist der Doppelpukt im vi-Editor ist ein großes "Ö"
    Antworten Direktlink
  • Markus schrieb am 7.4.2016 um 14:03 In der csharp Lösung:

    gpio.cs(20,27): error CS0019: Operator `==' cannot be applied to operands of type `RaspberryPiDotNet.PinState' and `bool'
    Antworten Direktlink
  • Kayden schrieb am 9.5.2016 um 18:19 De shopping non, ces petites robes ne sont ni de mon goût ni de mon style, mais que la couleur ensivashe à nouveau les rues oh que oui. Marre des noirs sinistres (et mochasses il faut bien le dire).
    Antworten Direktlink
  • Janese schrieb am 11.5.2016 um 18:51 Gave, I really appreciate your &q;uquunreview&toot;. You are a reviewer but at the same time also a reader. So I liked to read your impression as a reader. I will get my copy of TWELVE in July 2009.I read several books with a "flat" beginning. Despite your unreview – which I understand very well when I think about other books I read – I will give it a try and don't cancel my preorder.Anyway if there is a need for more unreviews please post them. http://svopbxz.com [url=http://hpnhxspkzcf.com]hpnhxspkzcf[/url] [link=http://dddhlwtzufa.com]dddhlwtzufa[/link]
    Antworten Direktlink
  • Ice schrieb am 14.5.2016 um 08:58 Por eso es que digo que muchos hablan de comunismo, sooiclisma, izquierda y demás, pero están justo en el extremo opuesto. La verdad es que Europa está cada vez más a la derecha.Un saludo. http://tmsuagaj.com [url=http://ttddywfakvc.com]ttddywfakvc[/url] [link=http://brfyvb.com]brfyvb[/link]
    Antworten Direktlink
  • Horst schrieb am 18.5.2016 um 00:33 Diese Anleitung hätte noch einen größeren Charme, wenn sie auch funktionieren würde.
    Beim Compilieren kommen Fehlermeldungen dass er die Referenzen wie piMode, delay, etc. nicht kennt.
    Weiterhin wurden bei der Installation Hinweise gegeben, dass zur Nutzung diese Library noch weitere Libraries erforderlich sind, damit es in C-Programmen genutzt werden kann.
    Antworten Direktlink

Kommentar verfassen


Name:
Text:
Erlaubte Tags: [code][/code]
Sicherheitsabfrage: