C++ fstream GPIO Trigger/Interrupt

[alexander_ro]

Ja der Code funktioniert auf einem Raspi mit Gentoo Linux sollte aber mit allen anderen halbwegs aktuellen Distributionen auch funktionieren. Wenn Du was findest das nicht geht wäre es nett wenn Du hier schreibst was es ist damit ich es reparieren kann. Du musst bei Deiner Anwendung halt aufpassen das der Drehgeber die Impulse nicht schneller generiert als die vom Controller verarbeitet werden können.

Hier der neue Link weil ich für die git Web Zugriffe ein anderes Programm benutze geht der oben nicht mehr. Die Domain ist aber die gleiche geblieben.
https://git.hts-software.de/cgit.cgi.../Gpio/Gpio.hpp

[NumberFive]

Ich habe ein Aktuelles Debian drauf da sollte der Kernel passen denke ich. Ja werde schreiben wenn ich was finde.

Das der Link jetzt anders ist habe ich schon gemerkt habe aber den Code schon gefunden gehabt danke für den neuen Link.

Bei dem wort Drehgeber habe ich wohl mich falsch Ausgedrückt bzw es ist halt so ein Poti was schalte da dreht ein Mensch dran nicht ein Motor deshalb hoffe ich das es klappt.
Lautstärke einstellen ist die Funktion.

[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.

[alexander_ro]

HDMI Sound ist ja nur Digital. Du musst auf der anderen Seite halt einen Digital/Analog Wandler haben der aus den Daten ein Analoges Signal macht. Ich habe für Sound eine USB Soundblaster Soundkarte. Will man den PWM vom Raspi Klinken Sound benutzen wird man den Treiber entfernen müssen und vermutlich für eine normale PWM Anwendung einen anderen Treiber benötigen. Weiß ich noch nicht wie das geht. Ich baue mal das I2C Ding das dauert so sicher ein paar Tage weil ich ja auch ein Programm für den Arduino brauche damit ich zum Testen zwischen Raspi und Arduino Daten verschieben kann.

Ich weiß da nichts genaues darüber aber die Controller können zum Teil über serielle Schnittstelle booten. Also er lädt sein Programm über die serielle Schnittstelle und beginnt erst dann mit der Ausführung. Dann kann es sein das Du den Port auf eine bestimmte Art beschalten musst damit er erkennen kann das Du nicht über seriell booten willst. Evtl. auch so ein Fuses Ding das man da das booten über seriell ausschalten muss. Oder ein bootloader macht das könnte auch sein.