Arduino Interrupt Drehzahlmessung Faulhaber Motor

[Maik H. (tyson)]

Guten Abend,

aktuell Versuche mit einem Arduino Uno den Encoder eines Faulhaber 
Motors auszulesen und daraus die Drehzahl zu bestimmt.

Der folgende Motor wird verwendet:  2342S012CR
und der folgende Encoder:           IE3-32

Das Signal wird über den Interrupt-Pin 2 ausgelesen, allerdings 
entspricht die angezeigte Drehzahl nicht der tatsächlichen, diese bewegt 
sich nur in einem kleinen nicht nachvollziehbaren Bereich.

Der Encoder hat drei Ausgangssignale, zwei um 90 Grad verschobene 
Rechtecksignale und einen Indeximpuls.
Bisher kam das Auslesen des Indexumpulses den tatsächlichen Werten am 
nächsten.
Der Wechsel des Interrupt-Modus hat auch keinen Erfolg gebracht.

Da ich noch Neuling bin habe ich mich an der folgenden Anleitung für die 
Messung der Drehzahl orientiert:
https://arduino-projekte.info/drehzahlmesser/

Das ist mein aktuelles Programm:

// Variablen
int MotorSpeed;          // Geschwindigkeit Motor

// Variablen Encoder
byte DZM_InputPin = 2;
volatile unsigned long RPM_T2, RPM_Count;
unsigned long RPM , RPM_T1;


// Eingaenge  
int Poti = A3;          // Analogwert fuer Drehzahlvorgabe durch Potentiometer 

// Ausgaenge Motor 
int Motor = 9;          // PWM-Signal fuer Motorgeschwindigkeit 
int in1 = 8;            // H-Brueckensteuersignal fuer Drehrichtung
int in2 = 7;            // H-Brueckensteuersignal fuer Drehrichtung


/********************************************************************************************************************************/
void setup() {

    // Allgemein 
    Serial.begin(9600);                               // Die Kommunikation mit dem seriellen Port wird gestartet fuer die Darstellung von Ergebnissen im seriellen Monitor 

    // Einstellungen Encoder 
    pinMode(DZM_InputPin, INPUT_PULLUP);              // Pin Encoder wird als Eingang gesetzt mit Pull-Down-Widerstand auf dem Arduino
    RPM_T1 = 0;                                       // Setzen der Zeitvariable T1
    RPM_T2 = 0;                                       // Setzen der Zeitvariable T2
    RPM_Count = 0;                                    // Setzen des Umdrehungsvariable 
    
    // Interrupt Einstellungen
    attachInterrupt(0, FunktionInterrupt, RISING);    // Encoder1 = Pin fuer Signal, FunktionInterrupt = aufzurufende Funktion bei Interrupt, RISING = Detektion der positiven Flanke
    
  
    // Einstellungen Motor
    pinMode(Motor, OUTPUT);                           // Pin Motor wird als Ausgang gesetzt
    pinMode(in1, OUTPUT);                             // Pin in1 wird als Ausgang gesetzt
    pinMode(in2, OUTPUT);                             // Pin in2 wird als Ausgang gesetzt

}

/**************************************************************************************************************************/
void loop() {
       
  // Motor ansteuern und Poti auslesen
  digitalWrite(in1, LOW);                           // Drehrichtung Motor festlegen (H-Bruecke)
  digitalWrite(in2, HIGH);                          // Drehrichtung Motor festlegen (H-Bruecke)
  MotorSpeed = analogRead(Poti);                    // Position des Potentiometers auslesen
  MotorSpeed = map(MotorSpeed, 0, 1023, 0, 255);    // 10 bit Potentiometerwert in 8 bit Wert umrechenen (Eingang = 10bit, Ausgang = 8bit)
  
  if (MotorSpeed < 8) MotorSpeed = 0;               // Abfangen von Summen des Motors bei zu geringen Drehzahlen 
  analogWrite(Motor, MotorSpeed);                   // PWM-Signal für Motorgeschwindigkeit ausgeben 

  // Encoder Drehzahlausgabe 
  if (RPM_T2 > RPM_T1) {
    RPM = (unsigned)(long)(60000 * RPM_Count / (RPM_T2 - RPM_T1));
    RPM_T1 = RPM_T2;
    RPM_Count = 0;
    }
  else {                                            // Abfangen von Drehzahl = 0 
      RPM = 0;
    }
  // Ausgabe der Drehzahl
  Serial.println(RPM);
}

// Funktion Interrupt 
void FunktionInterrupt() {
  
  RPM_Count++;                // Impuls wird um eins erhoeht
  RPM_T2 = millis();          // Zeit seit Start des Arduinos fuer Berechnung der Drehzahl
  
}

Vielleicht kann mir jemand weiterhelfen, sehe aktuell nicht den Fehler 
in dieser Umsetzung.
Vielen Dank

[Guest (Gast)]

Wie schnell dreht denn dein Motor? Eventuell kommt dein Programm nicht 
nach. So einen Encoder wertet man idr. eher mit einem Timer aus.

[Maik H. (tyson)]

Der Motor kann bis zu 6000 1/min drehen, wird allerdings im späteren 
Betrieb nicht schneller als 3000 1/min drehen.
Zu der Auswertung mit Timern hatte ich bisher noch nichts gelesen, die 
Interrupt-Variante erschien mir bisher schlüssig.

[Guest (Gast)]

Die Frage ist halt ob deine Zeitmessung genau genug ist. Ich kenne mich 
beim Atmel nicht so mit den Interrupts und der Priorisierung aus aber 
ich meine millis gibt den Wert einer Variable zurück die ebenfalls in 
einem Interrupt hochgezählt wird (Bin mir nicht absolut sicher). Je nach 
Gitter von deinem Pin und Millis Interrupt kann es sein das die Messung 
zu ungenau ist. Für die Drehzahl zu messen sollte der Indeximpuls 
ausreichend sein über die verschobenen Rechtecke kannst du zusätzlich 
noch Richtung und Rotor Winkel bestimmen. Ich würde das Ganze mit einem 
Timer machen. Such mal nach Timer Input Capture.

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Wie ist denn das in der Arduino IDE mit 'volatile'? Sonst sollte man 
Variablen, die in der ISR bearbeitet werden, so deklarieren.

[Veit D. (devil-elec)]

Hallo,

volatile nutzt er schon, haut hin. Nur liest er diese Werte in der loop 
ohne atomaren Zugriffsschutz aus und hat deswegen Datenverstümmelung.
Serial.print würde ich auch nur aller 1s machen.

[Maik H. (tyson)]

Wie kann ich den "atomaren Zugriffsschutz" einbringen, mit der Funktion 
"noInterrupts()"?

Serial.print ist aktuelle nur ein Platzhalter für ein LCD Display, werde 
die Zeit auf eine Sekunde erhöhen.

[m.n. (Gast)]

Maik H. schrieb:
> RPM_T2 = millis();

Die Zeitmessung erscheint mir doch ein wenig zu grob, und warum die Zeit 
im Interrupt gelesen wird, leuchtet mir nicht ein.

Der Encoder liefert bei 6000 UPM eine Ausgangsfrequenz von 3,2 kHz. 
Wieviele Werte werden den pro Sekunde benötigt? Die einfachste Messung 
(mit fester Torzeit) würde eine Sekunde warten und dann das Ergebnis aus 
RPM_Count ermitteln.
Aber bei potentiell auch niedrigen Drehzahlen wäre eine reziproke 
Messung doch wesentlich sinnvoller. Das läuft dann über Timer1 mit dem 
T1-Capture-Eingang, wodurch sich eine hohe Auflösung bei hoher Messrate 
ergibt.

Nur fürchte ich, daß man sich das nicht aus Arduino-LIBs zusammenklicken 
kann ;-)

[Veit D. (devil-elec)]

Maik H. schrieb:
> Wie kann ich den "atomaren Zugriffsschutz" einbringen, mit der Funktion
> "noInterrupts()"?

Nein. atomic block RESTORE
https://www.nongnu.org/avr-libc/user-manual/group__util__atomic.html

Und das mit der Zeitmessung überlegste dir auch nochmal. Wurde schon 
angesprochen. millis wäre auch zu ungenau, müßtest schon micros 
verwenden. Aber wie schon gesagt wurde ist diese Vorgehensweise nicht 
optimal, weil du nur von Puls zu Puls misst.

[Maik H. (tyson)]

Die Umsetzung mit dem "T1-Capture-Eingang" ist mir nicht klar geworden, 
gibt es eventuell ein nachvollziehbares Beispiel?

Aktuell habe ich den Code nochmal verändert, dabei nutze ich micros und 
zähle eine Sekunde lang die Impulse, die dann der Drehzahlbestimmung 
dienen.
Dabei dient der Kanal A des Encoders als Signal, da der Indeximpuls 
keine vernünftigen Werte liefert .

Aktuell erhalte ich hiermit Werte im Bereich von  60 bis 4440 RPM.
Bei der Ansteuerung mit dem Potentiometer fällt auf, dass im oberen 
Stellbereich eine geringere Drehzahländerung vorhanden ist.
Sind das die folgende des nicht genutzten "T1 Caputere Eingangs"?

// Variablen
int MotorSpeed;          // Geschwindigkeit Motor

// Variablen Encoder
// Motorpulse pro Umdrehung 
#define ENC_COUNT_REV 1
// Encoder Input 
#define ENC_IN 2
// Pulse vom Encoder
volatile long encoderValue = 0;
// Intervall 1 Sekunde
int interval = 1000000;
// Zähler für Microsekunden 
long previousMicros = 0;
long currentMicros = 0;
// Umdrehungen pro Minute
int rpm = 0;

// Eingaenge  
int Poti = A3;          // Analogwert fuer Drehzahlvorgabe durch Potentiometer 

// Ausgaenge Motor 
int Motor = 9;          // PWM-Signal fuer Motorgeschwindigkeit 
int in1 = 8;            // H-Brueckensteuersignal fuer Drehrichtung
int in2 = 7;            // H-Brueckensteuersignal fuer Drehrichtung


/********************************************************************************************************************************/
void setup() {

    // Allgemein 
    Serial.begin(9600);                               // Die Kommunikation mit dem seriellen Port wird gestartet fuer die Darstellung von Ergebnissen im seriellen Monitor 

    // Einstellungen Encoder 
    // Encoder Pin als Input mit Pullup  
    pinMode(ENC_IN, INPUT_PULLUP); 
    // Interrupt  
    attachInterrupt(digitalPinToInterrupt(ENC_IN), updateEncoder, RISING);
    // Start Timer 
    previousMicros = micros();
    
    // Einstellungen Motor
    pinMode(Motor, OUTPUT);                           // Pin Motor wird als Ausgang gesetzt
    pinMode(in1, OUTPUT);                             // Pin in1 wird als Ausgang gesetzt
    pinMode(in2, OUTPUT);                             // Pin in2 wird als Ausgang gesetzt

}

/**************************************************************************************************************************/
void loop() {
       
  // Motor ansteuern und Poti auslesen
  digitalWrite(in1, LOW);                           // Drehrichtung Motor festlegen (H-Bruecke)
  digitalWrite(in2, HIGH);                          // Drehrichtung Motor festlegen (H-Bruecke)
  MotorSpeed = analogRead(Poti);                    // Position des Potentiometers auslesen
  MotorSpeed = map(MotorSpeed, 0, 1023, 0, 255);    // 10 bit Potentiometerwert in 8 bit Wert umrechenen (Eingang = 10bit, Ausgang = 8bit)
  
  if (MotorSpeed < 8) MotorSpeed = 0;               // Abfangen von Summen des Motors bei zu geringen Drehzahlen 
  analogWrite(Motor, MotorSpeed);                   // PWM-Signal für Motorgeschwindigkeit ausgeben 

  // Umdrehungen jede Sekunde aktualisieren
  currentMicros = micros();
   if (currentMicros - previousMicros > interval) {
     previousMicros = currentMicros;
 
     // Berechnung Drehzahl
     rpm = (float)(encoderValue * 60 / ENC_COUNT_REV);
 
     // Displayausgabe wenn Wert gelesen
     if (rpm > 0) {
       Serial.print(rpm);
       Serial.println(" RPM");
    }
    encoderValue = 0;
   }
}
void updateEncoder()
{
  // Increment value for each pulse from encoder
  encoderValue++;
}

[Veit D. (devil-elec)]

Hallo,

a) noch ohne atomic

b) Zeile 12
warning: overflow in conversion from 'long int' to 'int' changes value 
from '1000000' to '16960' [-Woverflow]
   12 | int interval = 1000000;

zusätzlich unsigned, damit der Vergleich später hinhaut, also unsigned 
long

c) previousMicros und currentMicros müssen unsigned long sein

[Veit D. (devil-elec)]

Hallo,

wenn ich nichts übersehen habe, versuche mal dein Glück.

#include <util/atomic.h> 

// Variablen
unsigned int MotorSpeed;          // Geschwindigkeit Motor

// Variablen Encoder
// Motorpulse pro Umdrehung
const byte ENC_COUNT_REV = 1;
// Pulse vom Encoder
volatile unsigned long encoderValue;
// Intervall 1 Sekunde
const unsigned long interval = 1000000;
// Zähler für Microsekunden
unsigned long previousMicros;
unsigned long currentMicros;
// Umdrehungen pro Minute
int rpm;

// Eingaenge
const byte pinEncoder = 2;            // Encoder Input
const byte pinPoti = A3;          // Analogwert fuer Drehzahlvorgabe durch Potentiometer

// Ausgaenge Motor
const byte pinMotor = 9;          // PWM-Signal fuer Motorgeschwindigkeit
const byte pinIN1 = 8;            // H-Brueckensteuersignal fuer Drehrichtung
const byte pinIN2 = 7;            // H-Brueckensteuersignal fuer Drehrichtung


/********************************************************************************************************************************/
void setup() {

  // Allgemein
  Serial.begin(9600);                               // Die Kommunikation mit dem seriellen Port wird gestartet fuer die Darstellung von Ergebnissen im seriellen Monitor

  // Einstellungen Encoder
  // Encoder Pin als Input mit Pullup
  pinMode(pinEncoder, INPUT_PULLUP);
  // Interrupt
  attachInterrupt(digitalPinToInterrupt(pinEncoder), updateEncoder, RISING);
  // Start Timer
  previousMicros = micros();

  // Einstellungen Motor
  pinMode(pinMotor, OUTPUT);                           // Pin Motor wird als Ausgang gesetzt
  pinMode(pinIN1, OUTPUT);                             // Pin in1 wird als Ausgang gesetzt
  pinMode(pinIN2, OUTPUT);                             // Pin in2 wird als Ausgang gesetzt

}

/**************************************************************************************************************************/
void loop() {

  // Motor ansteuern und Poti auslesen
  digitalWrite(pinIN1, LOW);                // Drehrichtung Motor festlegen (H-Bruecke)
  digitalWrite(pinIN2, HIGH);               // Drehrichtung Motor festlegen (H-Bruecke)
  MotorSpeed = analogRead(pinPoti)/4;       // Position des Potentiometers auslesen und umrechen
                                            // 10 bit Potentiometerwert in 8 bit Wert umrechenen (Eingang = 10bit, Ausgang = 8bit)

  if (MotorSpeed < 8)
  {
    MotorSpeed = 0;               // Abfangen von Summen des Motors bei zu geringen Drehzahlen
  }
  
  analogWrite(pinMotor, MotorSpeed);                   // PWM-Signal für Motorgeschwindigkeit ausgeben

  // Umdrehungen jede Sekunde aktualisieren
  currentMicros = micros();
  if (currentMicros - previousMicros > interval)
  {
    previousMicros = currentMicros;

    // Berechnung Drehzahl
    unsigned long tempEncoderValue = 0;
    ATOMIC_BLOCK (ATOMIC_RESTORESTATE)          // cli()+sei() mit SREG Sicherung
    {  
      tempEncoderValue = encoderValue ; 
    }
    rpm = (int)(tempEncoderValue * 60.0 / ENC_COUNT_REV);  // Ergebnis landet in 'int'

    // Displayausgabe wenn Wert gelesen
    if (rpm > 0) {
      Serial.print(rpm);
      Serial.println(" RPM");
    }
    
  }
}
void updateEncoder()
{
  // Increment value for each pulse from encoder
  encoderValue++;
}

[Veit D. (devil-elec)]

Hallo,

kleine Korrektur.

ATOMIC_BLOCK (ATOMIC_RESTORESTATE)        
{  
   tempEncoderValue = encoderValue;
   encoderValue = 0;
}

[Einer K. (Gast)]

Maik H. schrieb:
> Die Umsetzung mit dem "T1-Capture-Eingang" ist mir nicht klar geworden,
> gibt es eventuell ein nachvollziehbares Beispiel?

Durchaus!
Aber ob Nachvollziehbar?
Das liegt mehr an dir, als am Beispiel.


Hier mal ein Ereigniszähler für einen Arduino mit ATMega328p
Man kann damit Ereignisse bis in den MHz Bereich zählen lassen.
Den Interval Code lasse ich mal weg, der sorgt nur dafür, dass jede 
Sekunde eine Anzeige kommt.

[Veit D. (devil-elec)]

Hallo,

den Trick mit dem union finde ich nett. Spart das shiften bzw. 
multiplizieren. Mußte das erstmal binär nachbauen und schauen ob das 
wirklich so funktioniert wie ich dachte. :-)  Jetzt habe ich dadurch 2 
Fragen.

a) Warum ist das union/struct AVR only?
b) Ist der Vorteil wenn der "Timer Source T1" zählt der, dass dadurch 
beim zählen keine zusätzlichen Interrupts erzeugt werden?  Im Vergleich 
wenn ein "normaler" Interrupteingang jeden Puls zählen müßte.

[Einer K. (Gast)]

a)
Eigentlich ist das Verhalten laut C++ undefiniert.
Der Gcc garantiert allerdings, dass das so funktioniert.
Bei anderen µC haben haben die Daten evtl. einen anderen Fußabdruck im 
Speicher, dann wird das so erstmal nix.
Wenns universell werden soll, dann eben schieben oder multiplizieren.

b)
Ja.
Wenn für jede Flanke ein Interrupt feuert, ist bei wenigen kHz Ende im 
Gelände. So geht selbst bei 1MHz kaum Rechenzeit drauf.

[m.n. (Gast)]

Veit D. schrieb:
> den Trick mit dem union finde ich nett. Spart das shiften bzw.
> multiplizieren.

Der Compiler wird den Code ohne Multiplikation schon selber hinbekommen.

Veit D. schrieb:
> Ist der Vorteil, wenn der "Timer Source T1" zählt der, dass dadurch
> beim Zählen keine zusätzlichen Interrupts erzeugt werden?

Das ist ein normaler torzeitgesteuerter Zähler, die Auflösung bei 
niedrigen Frequenzen bleibt daher relativ gering. Bei 1 Hz schwankt die 
Anzeige zwischen 0 und 1. T1-Capture wird hier garnicht verwendet.

Arduino Fanboy D. schrieb:
> Wenn für jede Flanke ein Interrupt feuert, ist bei wenigen kHz Ende im
> Gelände.

>= 100 kHz sind kein Problem: 10 µs sind schon eine lange Zeit. In Assembler 
programmiert geht es bis 1 MHz Eingangsfrequenz.

[Veit D. (devil-elec)]

Hallo,

alles klar, habe verstanden. Danke. Jetzt hoffen wir das der TO aus 
alledem auch einen Nutzen ziehen kann.

[Einer K. (Gast)]

m.n. schrieb:
> >= 100 kHz sind kein Problem: 10 µs sind schon eine lange Zeit. In Assembler
> programmiert geht es bis 1 MHz Eingangsfrequenz.
16 Takte für Call, iret Pus Pop und 32Bit Zähler hochsetzen?
Sportlich!
Sehr sportlich.

Wenn dann noch mehr ISR ihr Unwesen treiben, kann es so schnell mal ein 
Ereignis "übersehen".

Hach...
Assembler steht hier, glaube ich, erstmal nicht zu Debatte.

Der TE verwendet attachInterrupt().
Das ist einerseits recht bequem, erfordert andererseits einen Call in 
der ISR und führt so zu langen Push Pop Kaskaden.
Ja, lass die 100kHz die Grenze sein.... (nicht getestet), welche dann 
den armen kleinen 328p zur Vollbeschäftigung treibt.

Während er bei meinem Vorschlag noch reichlich "Luft" hat. Und eher kein 
Ereignis übersehen wird.

[m.n. (Gast)]

Arduino Fanboy D. schrieb:
> Ja, lass die 100kHz die Grenze sein.... (nicht getestet)

Das habe ich schon getestet.

Arduino Fanboy D. schrieb:
> Während er bei meinem Vorschlag noch reichlich "Luft" hat. Und eher kein
> Ereignis übersehen wird.

Der TO braucht Luft nach unten ;-)

[Maik H. (tyson)]

Vielen Dank für die informativen Antworten und besonderen Dank an Veit 
D. für den angepassten Code.

Die Bibliothek #include <util/atomic.h> habe ich bisher nicht in den 
Bibliotheken für den Arduino in dieser Form gefunden.

Nach dem folgenden Link habe ich nun die Bibliothek #include 
<SimplyAtomic.h> eingefügt und im Code einen Teil angepasst.

https://github.com/wizard97/SimplyAtomic

ATOMIC()                         // neuer Befehl für den Aufruf
{  
 tempEncoderValue = encoderValue ; 
 encoderValue = 0;
}

Spricht etwas gegen diese Bibliothek oder wird diese die gleiche 
Funktionalität beinhalten?

[Einer K. (Gast)]

Maik H. schrieb:
> Die Bibliothek #include <util/atomic.h> habe ich bisher nicht in den
> Bibliotheken für den Arduino in dieser Form gefunden.

Was auch kein Wunder ist, gehört sie doch zum Lieferumfang des GCC für 
AVR.
Natürlich darfst du den lieferumfang des Gcc ausblenden, bzw. unbeachtet 
lassen. Aber dann geht dir einiges/viel nützliches durch die Lappen.

Maik H. schrieb:
> Spricht etwas gegen diese Bibliothek oder wird diese die gleiche
> Funktionalität beinhalten?
Beide liegen im Quellcode vor!
Du könntest da rein schauen, und selber vergleichen.

Aber Vorsicht!
Auf die Art könnten sich ein Erkenntnisgewinn einstellen.
(hoffentlich kannst du damit umgehen)

[Veit D. (devil-elec)]

Hallo,

> Die Bibliothek #include <util/atomic.h> habe ich bisher nicht in den
> Bibliotheken für den Arduino in dieser Form gefunden.

also ich kompiliere immer erst und schaue ob was fehlt

> Spricht etwas gegen diese Bibliothek oder wird diese die gleiche
> Funktionalität beinhalten?

Muss leider mit einer Gegenfrage antworten. Warum eine fremde Lib 
verwenden wenn man das Original hat? Die Frage müßte zugleich die 
Antwort sein.

Ich denke jedoch die Idee mit der fremden Lib beruht auf dem 
Missverständnis das obige Lib angeblich fehlen würde.

"util/atomic.h" ist nur der letzte Teil vom Suchpfad und Suchinfo für 
den Compiler. Du siehst daran nur das die Headerdatei atomic.h in einem 
Verzeichnis namens util liegt. Wenn man jetzt einfach auf C: nach 
atomic.h suchen würde, dann erscheinen unzählige Angaben, je nachdem was 
alles an Programmiersoftware installiert ist. Deswegen gehe in den 
Arduino Installationspfad und starte dort die Suche nach atomic.h, 
sollte nur einmal vorkommen.

Welche du verwenden solltest sollte damit klar sein.

Wegen dem Sketch. Kein Problem, so lang war der nicht.
Die Lösung von ArduinoFanboy solltest du dir allerdings auch anschauen. 
Sind paar tolle Features drin. Man kann immer wieder von anderen lernen. 
Am Ende muss man das nutzen was man versteht und lesen kann und das noch 
nicht verstandene aber versuchen im Hinterkopf zubehalten. Irgendwann 
versteht man es und wird so Stück für Stück immer schlauer.

[Maik H. (tyson)]

Ja, es ist ein Missverständnis meinerseits. Bisher bin ich davon 
ausgegangen, dass alle Lib´s in "libaries" abgelegt sein müssen.
Die Antwort erweitert mein Verständnis dazu.


Die Datei habe ich im folgenden Pfad gefunden.
C:\Program Files (x86)\Arduino\hardware\tools\avr\avr\include\util

Mehrere Versuche diesen nun in für "until" in #include <util/atomic.h> 
einzusetzen schlugen fehl.

Wie sollte dieser Pfad-Aufruf aufgebaut sein?

#include <???/atomic.h>

Die Antworten von ArduinoFanboy sind bestimmt gut, allerdings kann ich 
aktuell wirklich nicht die Inhalte lesen und verstehen.
Leider fehlt mir aktuell die Zeit um dies in der Form nachzuvollziehen 
wie ich es gerne würde, vielleicht kann ich das nochmal nachholen.

[Einer K. (Gast)]

Maik H. schrieb:
> Wie sollte dieser Pfad-Aufruf aufgebaut sein?
So wie es in meinem Programm steht!
Auch der Veit D hats vollkommen korrekt in seinem Programm.

Selbst auf der Dokuseite zu atomic.h  findet sich das so.

[Maik H. (tyson)]

Der Fehler ist behoben.

Durch das Einbinden der der #include <SimplyAtomic.h> Bibliothek wurde 
die  <util/atomic.h> Bibliothek blockiert und konnte nicht eingebunden 
werden. Durch entfernen von SimplyAtomic.h, die dann nicht mehr benötigt 
wird, ist das Einbinden nun möglich.

Mein Gedanke war, dass ich die Bibliothek die nicht in dem libaries 
Verzeichnis liegt über den zugehörigen Pfad einbinden muss, damit es 
funktioniert.

Vielen Dank für die Mühe von euch in diesem Forum :-)

[Einer K. (Gast)]

Maik H. schrieb:
> Mein Gedanke war, dass ich die Bibliothek die nicht in dem libaries
> Verzeichnis liegt über den zugehörigen Pfad einbinden muss, damit es
> funktioniert.

Diese Methode wird verwendet: 
https://www.rapidtables.com/code/linux/gcc/gcc-i.html