C++ fstream GPIO Trigger/Interrupt

[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;
};