C++ fstream GPIO Trigger/Interrupt

[alexander_ro]

Ist ja auch ein Drehgeber wenn den Menschen bedienen gibt das sicher keine Probleme.

[NumberFive]

hast du das Thema PWM schon mal betrachtet ? Wenn ich jetzt mit deinem Code auf externe Libs verzichte brauche ich noch eine Lösung für I²C und PWM. Das PWM brauche ich für den Lüfter.

http://www.raspberry-projects.com/pi...-i2c-interface damit sollte das mit dem MCP23017 klappen der ist ja vom Protokoll her nicht wirklich schwer.

Aber bei PWM habe ich noch so gar keine Idee

[alexander_ro]

I2C habe ich bisher noch nichts gemacht. Unter Linux ist das ja auch nur ein Devicefile das man mit open öffnet und dann die Daten schreibt. Für den SPI bei einem Gnublin habe ich das mal gemacht.

// Copyright 2013 HTS-Software Unternehmensberatung
//                      Alexander Schucha
//
// This file is part of Athena-Api.
//
// Athena-Api is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Athena-Api is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with Athena-Api.  If not, see <http://www.gnu.org/licenses/>.

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>

#include <atomic>
#include <chrono>
#include <thread>
#include <time.h>
#include <iostream>
#include <fstream>

#include <sys/ioctl.h>
#include <linux/types.h>
#include <linux/spi/spidev.h>

class Spi
{
public:
  Spi (const std::string&  strChipSelect,
       const std::string&  strDevFile,
       const unsigned int  uiBandbreite = 100000,
       const unsigned char ucBitAnzahl  = 8,
       int                 iDebug = 0)            : strIntChipSelect (strChipSelect),
                                                    strIntDevFile    (strDevFile),
                                                    iIntDebug        (iDebug)
  {
  // Debug Messages
    if (iIntDebug == 1)
    {
      std::cout << "Start Spi Konstruktor ... " << std::endl;
      std::cout << "strIntChipSelect:    "      << strIntChipSelect << std::endl;
      std::cout << "strIntDevFile: "            << strIntDevFile    << std::endl;
    }
      
    iIntDevFile = open(strDevFile.c_str(), O_RDWR);


    if (iIntDevFile < 0)
      std::cout << "SPI Device File konnte nicht geöffnent werden (SPI-Kernel Modul geladen? root?)." << std::endl;

  // SPI Bandbreite einstellen
    if (ioctl (iIntDevFile, SPI_IOC_WR_MAX_SPEED_HZ, &uiBandbreite))
      std::cout << "SPI Bandbreite konnte nicht eingestellt werden" << std::endl;

  // SPI Anzahl Bits einstellen
    if (ioctl (iIntDevFile, SPI_IOC_WR_BITS_PER_WORD, &ucBitAnzahl))
      std::cout << "SPI Anzahl Bits konnte nicht eingestellt werden" << std::endl;
  }

  int operator<< (std::string strDaten)
  {
    if (iIntDebug == 1)
      std::cout << "Daten länge: " << strDaten.size () << std::endl;

    int status;
    struct spi_ioc_transfer xfer;

    xfer.tx_buf = (unsigned long) strDaten.c_str ();
    xfer.len = strDaten.size ();
    xfer.rx_buf = 0;
    xfer.delay_usecs = 0;
    xfer.speed_hz = 0;
    xfer.bits_per_word = 0;

    status = ioctl(iIntDevFile, SPI_IOC_MESSAGE(1), &xfer);

    if ((status < 0) && (iIntDebug == 1))
      std::cout << "SPI Daten senden fehlgeschlagen." << std::endl;
  }


  int operator<< (__u8* cDaten)
  {
    if (iIntDebug == 1)
      std::cout << "Daten länge: " << sizeof (__u8) << std::endl;

    int status;
    struct spi_ioc_transfer xfer;

    xfer.tx_buf = (unsigned long) cDaten;
    xfer.len = sizeof (__u8);
    xfer.rx_buf = 0;
    xfer.delay_usecs = 0;
    xfer.speed_hz = 0;
    xfer.bits_per_word = 0;

    status = ioctl(iIntDevFile, SPI_IOC_MESSAGE(1), &xfer);

    if ((status < 0) && (iIntDebug == 1))
      std::cout << "SPI Daten senden fehlgeschlagen." << std::endl;
  }

  ~Spi (void)
  {
    if (iIntDebug == 1)
      std::cout << "Start Spi Destructor ... " << std::endl;

    close(iIntDevFile);
  }

private:
  std::string strIntChipSelect;
  std::string strIntDevFile;

  int iIntDevFile;

  int iIntDebug;
};

Das sollte relativ leicht zum umbauen sein ist ja beides eine serielle Verbindung. Geräte Datei öffnen und Daten senden/empfangen müsste fast gleich sein nur die Daten für die Abwicklung des Protokolls sind unterschiedlich. Ich kann so was schon schreiben weiß aber noch nicht was ich zum Testen benutzen könnte. Vielleicht habe ich noch ein Arduino Teil herumliegen.

PWM habe ich auch noch nicht gemacht würde es aber auch schon brauchen. Kommt halt darauf an ob Du das in Software oder Hardware machen willst. Unter Linux kann man Software PWM recht Rechenzeit sparsam bauen weil der Kernel in der Wartezeit was anderes tun kann. Hardware PWM geht auch wieder über die Devicefiles.

so etwa:
https://jumpnowtek.com/rpi/Using-the...WM-timers.html

[NumberFive]

Nach dem Code den ich gefunden habe ist I²C noch einfacher siehe Link im Pos davor.
PWM ob Hardware oder Software ist mir im Moment egal da ich nur einmal brauche für den Lüfter und ich bin der Meinung der PI hat nur ein Hardware PWM.
Hast du eine Link zu der Beschreibung der DeviceFiles ich finde da immer nix ?

Ich habe mal mein test PRG für die Pins angehängt. Ein bisschen was habe ich umgebaut. Die Exception sind in der "richtigen" Software dann drin. Bei Test PRG habe ich es mal Weg gelassen.
Ich hoffe das so Ok für dich. Auch habe ich Programm in dem ich es Nutzen möchte einen Logger das hier auskommentiert.

Wenn man im Netz sucht kommt halt immer bei einer der beiden Libs raus. Libs machen halt immer das Crosscompile so aufwendig.

[HaWe]

Nach dem Code den ich gefunden habe ist I²C noch einfacher siehe Link im Pos davor.
PWM ob Hardware oder Software ist mir im Moment egal da ich nur einmal brauche für den Lüfter und ich bin der Meinung der PI hat nur ein Hardware PWM.
Hast du eine Link zu der Beschreibung der DeviceFiles ich finde da immer nix ?

Ich habe mal mein test PRG für die Pins angehängt. Ein bisschen was habe ich umgebaut. Die Exception sind in der "richtigen" Software dann drin. Bei Test PRG habe ich es mal Weg gelassen.
Ich hoffe das so Ok für dich. Auch habe ich Programm in dem ich es Nutzen möchte einen Logger das hier auskommentiert.

Wenn man im Netz sucht kommt halt immer bei einer der beiden Libs raus. Libs machen halt immer das Crosscompile so aufwendig.

Soweit ich weiß, hat der Pi mit 40 Pins 2 Hardware pwm (BCM 12+13) und prinzipiell beliebige Software pwm. Hardware pwm braucht root Rechte.

[alexander_ro]

Für den I2C habe ich schon mal eine Klasse angefangen zu bauen bin aber noch nicht ganz fertig.

Für PWM war der Link oben als Info gedacht. Dort stehen im unteren Teil die Devicefile Namen.

Der schreibt hier zum Beispiel den Wert "10000000" in die Datei "/sys/class/pwm/pwmchip0/pwm0/period". Die Datei einfach mit open öffnen und dann mit wirte den Wert in die Datei schreiben. Bei mir ist allerdings das Verzeichnis "/sys/class/pwm/" leer. Vermutlich muss man PWM erst irgendwie aktivieren beim booten. Der Raspi lädt ja nicht automatisch alle Treiber. Den Kerneltreiber wird man auch noch laden müssen.

Man findet erstaunlich wenig zu Hardware PWM und Raspi. Einige schreiben das der einzige PWM Anschluß für den Audio Port benutzt wird.

Software PWM ist ja einfach: ein Thread in dem Du den Port aus und ein schaltest und nach jedem Schalten ein CPU freundliche Wartezeit einbaust. (z.B. mit std::this_thread::sleep_for(std::chrono::milliseco nds(100)). Damit kannst Du dann die Zeit für Port ein oder aus einstellen. Wenn Du das in einer Lamda Funktion machst kannst Du über zwei externe Variablen die Zeiten beliebig einstellen. Das wollte ich als eine Spezialisierung meiner Gpio Klasse bauen.

Ich wusste doch ich habe das schon mal gemacht. Für einen Temperatursensor auch für den Gnublin ist aber alles der Sympathische Pinguin ...

// Copyright 2014 HTS-Software Unternehmensberatung
//                Alexander Schucha
//
// This file is part of Athena-Api.
//
// Athena-Api is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Athena-Api is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with Athena-Api.  If not, see <http://www.gnu.org/licenses/>.

//******************************************************************************
//*  Neuentwicklung                                                 15.08.2014 *
//******************************************************************************

// Device File anlegen:
// mknod /dev/i2c-1 c 89 1
//
// Das Programm benötigt root Rechte !!!
// Wegen den Zugriffen auf die Hardware-Ports

#include <cstring>

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>

#include <atomic>
#include <chrono>
#include <thread>
#include <time.h>
#include <iostream>
#include <fstream>

#include <sys/ioctl.h>
#include <linux/types.h>

#include <linux/i2c.h>
#include <linux/i2c-dev.h>

class I2C
{
public:
  I2C (const std::string&  strDevFile,
       const unsigned char ucI2cAdr,
       int                 iDebug = 0) : strIntDevFile (strDevFile),
                                         ucIntI2cAdr   (ucI2cAdr),
                                         iIntDebug     (iDebug)
  {
  // Debug Messages
    if (iIntDebug == 1)
    {
      std::cout << "Start I2C Konstruktor ... " << std::endl;
      std::cout << "strIntDevFile: "            << strIntDevFile    << std::endl;
    }

    iIntDevFile = open(strDevFile.c_str(), O_RDWR);

    if (iIntDevFile < 0)
    {
      std::cout << "I2C Device File konnte nicht geöffnent werden." << std::endl;
      exit (0);
    }

    if (ioctl(iIntDevFile, I2C_SLAVE, ucI2cAdr) < 0)
    {
      std::cout << "I2C Adresse als Slave: " << ucI2cAdr << std::endl;
      exit (0);
    }
  }


  friend short I2c::operator>> (short iReturn, short iValue)
  {
    return getTemp ();
  }


  short getTemp (void)
  {
  // Lese einen Wert über den I2C Bus.
    unsigned char ucBuffer[2];
    int           iLaenge = 2;

    memset (ucBuffer, 0, sizeof (ucBuffer));

    if (read(iIntDevFile, ucBuffer, iLaenge) != iLaenge)
      std::cout << "I2C lesen fehlgeschlagen, Länge: " << iLaenge << std::endl;

  // MSB speichern
    short sWert = ucBuffer[0];

  // MSB an die richtige position schieben.
    sWert <<= 8;

  // LSB an das MSB anfügen
    sWert |=  ucBuffer[1];

  // Bit 0-4 werden nicht benutzt beim LM75
    sWert >>= 5;

  // Konvertiere die Daten in den Temperatur Wert.
    if(ucBuffer[0] & 0x80)
    {
    // Temperatur negativ
      sWert =  sWert | 0xF800;
      sWert =~ sWert + 1;
      sWert = sWert * (-0.125);
      return sWert;
    }
    else
    {
    // Temperatur positiv
      sWert = sWert * 0.125;
     return sWert;
    }
  }

  ~I2c (void)
  {
    if (iIntDebug == 1)
      std::cout << "Start I2C Destructor ... " << std::endl;

    close(iIntDevFile);
  }

private:
  unsigned char ucIntI2cAdr;
  std::string   strIntDevFile;

  int iIntDevFile;

  int iIntDebug;
};

[NumberFive]

Dank die Infos muss ich jetzt mal verarbeiten.

Selbst wenn der PWM für den Sound verwendet würde sollte das bei mir egal sein den ich hole den Sound per HDMI aus dem PI. Und das man dafür den PWM braucht kann ich mir gerade nicht so ganz vorstellen.
Leider war ich das ganze WE unterwegs und konnte das jetzt erst lesen. Leider muss ich mich erstmal um das Stromversorgungs Problem Kümmern den das gefährdet gerade das ganz Projekt.

Der Amtel der Stromversorgung Bootet nicht wenn die RX Leitung angeschlossen ist. Aber ich will den Thread nicht Kapern. Ich melde mich so bald ich an dem Thema I²C und PWM wieder drin bin.

Eines noch die ganzen Sachen kommen in einen Systemd Backend Dienst so das rechte hier nicht so problematisch sind. Die GUI reden mit dem Backend per TCP.

Aber das sollte alles auf meiner HP zu lesen sein Link in der Fußzeile.