Port Übernahme in Library ?

Hallo,

bin dabei eine Lib zu bauen für meinen GrayEncoder, arbeitet mit Hallsensoren und Magneten.

Erst einfache Funktion zusammengestellt, dann geschafft wie man einen Port einer Funktion übergibt. Funktioniert.
Und nun wollte ich daraus eine Lib bauen, weil ich mehrere gekapselte Rückgabewerte benötige.
Und nun scheitert es an der Portübergabe an die Lib. Weil das mit Zeigern und call by Referenz geschieht.

Was ist an der Lib noch falsch?

hier der Sketch der für sich funktioniert

#include <SPI.h>
#include <DogLcdSPI.h>  // nutzt Hardware SPI

// Struktur Deklaration
struct TLE4905  {              // Typname "TLE4905"    
   byte Phase_A;
   byte Phase_B;
   int Direction;
} Sektor1, Sektor2, Sektor3;      // Strukturvariablen Sektor1, Sektor2, ...

volatile int enc_counter;    // Zähler

DogLcdSPI lcd(22, 24);


void setup()  {
  
  pinMode(53, OUTPUT);
  SPI.begin();

  lcd.begin(DOG_LCD_M163);

  Sektor3.Phase_A = 4;   // Port.C Bit 4
  Sektor3.Phase_B = 5;   // Port.C Bit 5    
}


void loop() {

  Sektor3.Direction = GrayEncoder(&PINC, Sektor3.Phase_A, Sektor3.Phase_B);
    
  lcd.setCursor(0,1);
  lcd.print(enc_counter); lcd.print(" ");
  
  lcd.setCursor(0,2);
  lcd.print(Sektor3.Direction); lcd.print(" ");
  
}   // loop Ende


// ****** Funktionen ******* //

int GrayEncoder (volatile uint8_t *Port, byte A, byte B)
{
  static int enc_last = 0x02;
  int i = 0;
  static int Direction = 0;
  byte PHASE_A=0;
  byte PHASE_B=0;

  PHASE_A = (*Port >> A & 1);  // einzelnes Bit heraus fischen
  PHASE_B = (*Port >> B & 1);

  lcd.setCursor(13,0); lcd.print(PHASE_B); 
  lcd.setCursor(15,0); lcd.print(PHASE_A);
  
  if( PHASE_A )  {
    i = 1;
  }
  
  if( PHASE_B )  {
    i ^= 3;           // convert gray to binary
  }
  
  i -= enc_last;      // difference new - last

  if( i & 1 )  {                 // bit 0 = value (1)
    enc_last += i;               // store new as next last
    enc_counter += (i & 2) - 1;  // bit 1 = direction (+/-), Zähler
    Direction = (i & 2) - 1;     // Richtungsanzeige (+1 / -1)
  }
  return Direction;
}

Compilermeldung mit der Lib.

Arduino: 1.6.8 (Windows 10), Board: "Arduino/Genuino Mega or Mega 2560, ATmega2560 (Mega 2560)"

GrayEncoder:17: error: invalid conversion from 'volatile uint8_t* {aka volatile unsigned char*}' to 'uint8_t {aka unsigned char}' [-fpermissive]

GrayEncoder Sektor3 (&PINC, 4, 5); // Port.C an Pin "Bit 4", "Bit 5"

^

In file included from C:\Users\Worker\Documents\Arduino\libraries\GrayEncoder\examples\GrayEncoder\GrayEncoder.ino:13:0:

C:\Users\Worker\Documents\Arduino\libraries\GrayEncoder/GrayEncoder.h:12:5: error: initializing argument 1 of 'GrayEncoder::GrayEncoder(uint8_t, uint8_t, uint8_t)' [-fpermissive]

GrayEncoder (volatile uint8_t, uint8_t, uint8_t); // Port, Port.Bit, Port.Bit

^

exit status 1
invalid conversion from 'volatile uint8_t* {aka volatile unsigned char*}' to 'uint8_t {aka unsigned char}' [-fpermissive]

im Anhang die Lib Dateien.

GrayEncoder.h (862 Bytes)

GrayEncoder.cpp (887 Bytes)

GrayEncoder.ino (697 Bytes)

Hier steht doch, wie es gehen sollte Frequently Asked Questions.

Deine lokale Variable muss dann wohl auch ein (volatile unsigned char*) werden.

Lass die Variable doch als Zeiger. Dann geht es. Wenn du Ports so "per Value" anspricht wird glaube ich immer der Inhalt genommen. Nicht das Register selbst.

Und gewöhne dir an Variablen in Konstruktoren immer über Initialisierungslisten zu setzen

Hallo,

den Link kenne ich, damit habe ich die Funktion ohne Lib gebaut, nur steht da nichts von char :astonished:

void set_bits_func_correct (volatile uint8_t *port, uint8_t mask)
{
  *port |= mask;
}

set_bits_func_correct (&PORTB, 0x55);

Die Initialisierungsliste muß in die .cpp Datei?
Bei allen was ich lese, steht das immer im Abschnitt einer ... class ... private ... public ..., was die .h Datei wäre,
nur im Header baut man doch keine Konstruktoren. :astonished: Ich quäle mich mal wieder.

nur steht da nichts von char

:confused: :confused:

uint8_t = unsigned char

Doc_Arduino:
Die Initialisierungsliste muß in die .cpp Datei?

Ja. Geht auch ohne aber es ist nicht gut und inkonsistent, da sie für Konstanten, Referenzen und andere Objekte sowieso verwenden musst.

Alternativ zu Zeigern kannst du hier auch eine Referenz verwenden. Dann sparst du dir im restlichen Code die Dereferenzierung. Aber es muss entweder ein Zeiger oder eine Referenz sein

Da stehen die bytes die volatile byte* werden sollten

  GrayEncoder (volatile uint8_t, // daaaaaaaaaaaaaaaaaa
   uint8_t, uint8_t);   // Port, Port.Bit, Port.Bit

  volatile uint8_t PORT = 0; // und daaaaaaaaaaaa

Hallo,

jetzt bin ich total wuschig.

wenn uint8_t = unsigned char ist, dann war das ein Fehler von mir, habe das mit byte gleich gesetzt, 8 Bit eben.

Muß ich das nun in volatile byte* oder volatile unsigned char* abändern?
Momentan gibts hier scheinbar einen kleinen Widerspruch.
Weil mit uint8_t hatte ich ja nun die ganze Zeit ein unsigned char. Zwar unbewußt, aber war da.

Ich gehe jetzt davon aus, das muß volatile byte* werden. Danke schön.

Habe das nun alles auf byte geändert. Fehlerfrei wird es kompiliert wenn das Referenzzeichen & im Sketch Code steht. Nehme ich das weg oder ersetze es durch den Pointer *, wird nicht kompiliert.

GrayEncoder Sektor3 (&PINC, 4, 5);  // Port.C an Pin "Bit 4", "Bit 5"

Aber, trotz fehlerfreier Kompilierung, passiert überhaupt nichts. Die Rückgabewerte ändern sich nicht.
Ich vermute mal, zu viele Pointer ... ?

Wenn das mit einem Objekt laufen würde, würde ich mich an ordentliche Initialisierungsliste ranmachen.

GrayEncoder.h (846 Bytes)

GrayEncoder.cpp (875 Bytes)

GrayEncoder.ino (695 Bytes)

falsch:

GrayEncoder::GrayEncoder (volatile byte *_Port, byte _A, byte _B)
{
  *PORT = *_Port;

richtig:

GrayEncoder::GrayEncoder (volatile byte *_Port, byte _A, byte _B)
{
  PORT = _Port;

Glaube ich jedenfalls.

Ich würde für das eine Bit keine direkten Portzugriffe benutzen, ist das so zeitkritisch?

Doc_Arduino:
Habe das nun alles auf byte geändert. Fehlerfrei wird es kompiliert wenn das Referenzzeichen & im Sketch Code steht. Nehme ich das weg oder ersetze es durch den Pointer *, wird nicht kompiliert.

Es ist sehr erschreckend was angesichts der Anzahl deiner Postings an Grundlagen fehlt.

byte = unsigned char = uint8_t

& hat mehrere Bedeutungen. Bei Zeigern bedeutet es "Adresse von". Dann brauchst du es natürlich, weil du die Adresse übergeben musst

Was soll dieser Blödsinn?

  *PORT = *_Port;

Wieso dereferenzierst du das hier? Ist dir klar was du da machst? Du musst den Zeiger selbst zuweisen!! Nicht den Inhalt.

Die Dereferenzierung brauchst du erst wenn du den Zeiger verwendest

Hallo,

oh man. Vielen Dank. Funktioniert.

Das Referenzzeichen & im Sketch muß bleiben? Weil Serenifly was von "entweder oder" schrieb?
Das wäre ja nun immer noch gemischt. Also Pointer und Referenz. Geht aber scheinbar nicht anders.

Also gebe ich dem Objekt mit & einen Referenzwert von PINC mit, was auch immer das ist. Inhalt, Adresse?
Der Konstruktor nimmt sich davon die Adresse und gibt die von _Port nach PORT weiter.
Wird also erstmal nur durchgereicht.
Und in der Funktion wird dann mittels Pointer *PORT wieder auf die Adresse vom Port.C zugegriffen.
So richtig?

Update:
Grundlagen. Na eigentlich sind die da. Ihr bringt mich aber immer durcheinander.
Das wäre meine nächste Frage gewesen. Hab das nochmal nachgelesen.
und kam dann wieder ins sichere Fahrwasser.
das uint8_t = byte = unsigned char sind
Ich weis jetzt im nachhinein auch nicht warum es dann einen Unterschied machen ob ich
uint8_t oder byte oder unsigned char in die Lib schreiben soll wenn alles das selbe ist.

Ich sollte das ja ändern. Weil angeblich falsch.

Wegen * und &
Ich hatte mir das bis jetzt so gemerkt das ein Pointer sich immer eine Adresse merkt und & direkt ohne Kopie auf den Wert zugreift.

Eine Referenz ist ein automatisch dereferenzierter konstanter Pointer.

Pointer und Referenz werden beide durch eine Adresse dargestellt.

Hallo,

halbwegs klar. Wenn du mir jetzt noch das Fremdwort "Dereferenzierung" erklärst, wird es glasklar.
Dann kann ich mich an die Initialisierungsliste rantrauen.
Was nun mit dem uint8_t und unsigned char los war kannst du auch nicht mehr auseinanderklamüsern?

Bei Pointern brauchst du das * oder [] um auf den Wert zu kommen,
bei den Referenzen kommst du nicht an die Adresse, sondern immer nur direkt an den Wert.

char zeichen = 'X';

char* pZeichen = &zeichen;
char& rZeichen = zeichen;

void setup() {
  Serial.begin(115200);
  Serial.print(F("*pZeichen = "));
  Serial.println(*pZeichen);
  Serial.print(F(" rZeichen = "));
  Serial.println(rZeichen);
}
void loop() {}
*pZeichen = X
 rZeichen = X

Doc_Arduino:
Also gebe ich dem Objekt mit & einen Referenzwert von PINC mit, was auch immer das ist. Inhalt, Adresse?

Ein Zeiger ist eine Adresse. Mit & übergibst du die Adresse einer Variablen. Um dann den Inhalt zu haben schreibst du * davor.

int var = 5;

int* p_var = &var;    //Zeiger auf int und Adresse von var zuweisen

*p_var = 10;    //Zeiger dereferenzieren um den Inhalt anzusprechen

Dann gibt es noch Referenzen. Diese sind eingeschränkter, aber auch nicht so fehleranfällig. Sie müssen direkt bei der Deklaration initialisiert werden (deshalb braucht man da bei Klassen eine Initialisierungsliste) und sind danach fest. Sie können nicht NULL sein. Aber sie müssen auch nicht extra dereferenziert werden

int var = 5;

int& r_var = var;   //muss unbedingt in einem Schritt geschehen

r_var = 10;    //kann wie eine normale Variable angesprochen werden

Hallo,

der "Dereferenzierungsoperator" ist nichts weiter als das Pointerzeichen __* __.
Deutsch, Symbol für den Zeiger. Das hätte ja mal gleich einer sagen können. :slight_smile:
Das klingt und liest sich alles plausibel. Ich denke das ist nun für mich klar. Alles nachvollziehbar.
Danke erstmal dafür.

Zurück zur Lib. Hab die Initialisierungsliste eingefügt, mußte "eigentlich" nur aufräumen und alles an die richtigen Stellen schreiben. Ist das jetzt so richtig? Es gibt dafür bestimmt auch verschiedene Schreibweisen. Diese wäre für mich leichter nachvollziehbar, wenn das so korrekt ist.
Oder gibts nochwas zu verbessern, wo wir schon einmal dabei sind?
Es kompiliert jedenfalls immer noch fehlerfrei und funktioniert mit 3 Objekten soweit richtig.

Header:

// Deklaration der Klasse
// GrayEncoder.h

#ifndef GrayEncoder_h
#define GrayEncoder_h

#include <Arduino.h>

class GrayEncoder  {     // Klassenname "GrayEncoder"

  private:                      // nur intern zugängliche Elemente ...
    int enc_last;           	// Startwert 2, weil TLE4905 low aktiv
    volatile int enc_counter;   // Zähler
    int direction;              // Richtungsanzeige  +1 / -1
    byte A;                     // erste Phase
    byte B;                     // zweite Phase
    volatile byte* PORT;        // verwendeter Port
	
  public:	                // von außen zugängliche Elemente ...
    GrayEncoder (volatile byte*, byte, byte);    // Port, Port.Bit, Port.Bit
    void encode();
    int getCounter()  { return enc_counter; }    // Getter-Methode, Zählerrückgabe
    int getDirection()  { return direction; }    // Getter-Methode, Richtungsanzeige    	
		
}; 

#endif

Quelldatei:

// Definition der Klasse
// GrayEncoder.cpp

#include "GrayEncoder.h"

// Konstruktor ::
GrayEncoder::GrayEncoder (volatile byte *p_Port, byte _A, byte _B)
{ 
  // Initialisierungsliste
  PORT = p_Port;	
  A = _A;
  B = _B; 
  enc_last = 0x02;  // Startwert b11, weil TLE4905 low aktiv
  enc_counter = 0;  // Zähler
  direction = 0;    // Richtungsanzeige  +1 / -1
}	

// ab hier Scopes/Bereichsoperator ::
void GrayEncoder::encode()  
{
  int i = 0;
  byte PHASE_A = 0;
  byte PHASE_B = 0;

  PHASE_A = (*PORT >> A & 1);  // einzelnes Bit heraus fischen
  PHASE_B = (*PORT >> B & 1);
  
  if( PHASE_A )  {
    i = 1;
  }
  
  if( PHASE_B )  {
    i ^= 3;           // convert gray to binary
  }
  
  i -= enc_last;      // difference new - last

  if( i & 1 )  {                 // bit 0 = value (1)
    enc_last += i;               // store new as next last
    enc_counter += (i & 2) - 1;  // bit 1 = direction (+/-), Zähler
    direction = (i & 2) - 1;     // Richtungsanzeige (+1 / -1)
  } // Definition der Klasse
// GrayEncoder.cpp

#include "GrayEncoder.h"

// Konstruktor ::
GrayEncoder::GrayEncoder (volatile byte *p_Port, byte _A, byte _B)
{ 
  // Initialisierungsliste
  PORT = p_Port;	
  A = _A;
  B = _B; 
  enc_last = 0x02;      // Startwert b11, weil TLE4905 low aktiv
  enc_counter = 0;      // Zähler
  direction = 0;        // Richtungsanzeige  +1 / -1
}	

// ab hier Scopes/Bereichsoperator ::
void GrayEncoder::encode()  
{
  int i = 0;
  byte PHASE_A = 0;
  byte PHASE_B = 0;

  PHASE_A = (*PORT >> A & 1);   // einzelnes Bit heraus fischen
  PHASE_B = (*PORT >> B & 1);
  
  if( PHASE_A )  {
    i = 1;
  }
  
  if( PHASE_B )  {
    i ^= 3;           // convert gray to binary
  }
  
  i -= enc_last;      // difference new - last

  if( i & 1 )  {                 // bit 0 = value (1)
    enc_last += i;               // store new as next last
    enc_counter += (i & 2) - 1;  // bit 1 = direction (+/-), Zähler
    direction = (i & 2) - 1;     // Richtungsanzeige (+1 / -1)
  }
  
}

Whandall:
Ich würde für das eine Bit keine direkten Portzugriffe benutzen, ist das so zeitkritisch?

gute Frage, hatte ich überlesen. Noch ist das nicht wirklich zeitkritisch, noch komme ich mittels Polling bestens zu recht. Die Signaländerung der Sensoren steht im kürzesten Fall ca. 26ms an. In der Zeit muß die loop das mitbekommen haben. Serielles Debugging könnte stören, deshalb lasse ich mir viel auf dem Display anzeigen statt seriell auszugeben. Anzahl der Sensoren beträgt später mindestens 20.

Hab die Initialisierungsliste eingefügt

Nein, hast du nicht :confused:

Bei dir geht es auch ohne, aber bei Referenzen, Konstanten oder Objekten braucht man die unbedingt. Deshalb ist es besser man macht es gleich einheitlich.

Außerdem kannst du dann einfach das schreiben:

GrayEncoder::GrayEncoder (volatile byte* port, byte A, byte A) : PORT(port), A(A), B(B), enc_last(0x02)
{
}

So muss man sich nicht mehr mit unterschiedlichen Namen herumärgern (wobei man da auch den this-Zeiger verwenden könnte um die Variable in der Klasse anzusprechen).

Damit kannst du dann auch einfach PORT, A und B als const deklarieren. Was bei dir nicht geht.

Hallo,

wie nennt man das dann was ich in der Lib geschrieben habe?

Ich meine ...

int enc_last;
ist eine Deklaration

enc_last = 5;
ist eine Initialisierung

und
int enc_last = 5;
ist auch eine Initialisierung die eine Deklaration beinhaltet.

Moment.
Okay, ich glaube ich habs langsam. Die Initialisierungsliste gehört nicht in die geschweifte Klammer!
Du sagst, die Variablennamen kann man gleich ziehen, der Compiler weis was wohin gehört?
Das wäre gleichzeitig mein Standard Konstruktor?
Wenn ich hier drin eine Variable vergesse zu initialisieren, dann hat sie einen Zufallswert?
Wie eine lokale Variable in einer normalen Funktion ohne init.
Und ganz wichtig, die Deklaration bestimmt die Initialisierungsreihenfolge, nicht die Liste.
Am besten die Deklaration wie die Initliste sortieren. :slight_smile:
Jetzt müßte ich das doch gefressen haben ...

Mit ausführlichen Namen damit ich sehe was wohin gehört ...

GrayEncoder::GrayEncoder (volatile byte* p_Port, byte _A, byte _B):
  PORT(p_Port),
  A(_A),
  B(_B),
  enc_last(0x02),  
  enc_counter(0),
  direction(0)  
{
}

Hallo,

hab die weiter ausgebaut und mit const ergänzt.
Ist das jetzt soweit erstmal alles i.O. und syntaktisch korrekt?
Möchte ungern vielleicht verzeihliche Fehler mitschleppen. Wenn dann jetzt richtig.
Die Variablennamen ziehe ich später gleich, da ich mit Klassen erst warm werde möchte ich noch wissen und sehen was wo hinkommt bzw. stehen muß.

// Deklaration der Klasse
// GrayEncoder.h

#ifndef GrayEncoder_h
#define GrayEncoder_h

#include <Arduino.h>

class GrayEncoder  {     // Klassenname "GrayEncoder"

  private:                      // nur intern zugängliche Elemente ...
    
    volatile byte const* PORT;  // verwendeter Port
    byte const PinA;            // Pin Port.Bit erste Phase
    byte const PinB;            // Pin Port.Bit zweite Phase
    int enc_last;               // Startwert 2, weil TLE4905 low aktiv
    volatile int enc_counter;   // Zähler
    int direction;              // Richtungsanzeige  +1 / -1
    byte Phase_A;		// erste Phase
    byte Phase_B;		// zweite Phase
	
	
  public:	             // von außen zugängliche Elemente ...
    GrayEncoder (volatile byte*, byte, byte);   // Port, Port.Bit, Port.Bit
    void encode();
    int getCounter()  { return enc_counter; }	// Getter-Methode, Zählerrückgabe
    int getDirection()  { return direction; }	// Getter-Methode, Richtungsanzeige    	
    int getA()  { return Phase_A; }    		// Getter-Methode, Signal von Phase A
    int getB()  { return Phase_B; }    		// Getter-Methode, Signal von Phase B
		
}; 

#endif
// Definition der Klasse
// GrayEncoder.cpp

#include "GrayEncoder.h"

// Konstruktor ::
GrayEncoder::GrayEncoder (volatile byte *p_Port, byte _A, byte _B):
  // Initialisierungsliste
  PORT(p_Port),	
  PinA(_A),
  PinB(_B),
  enc_last(0x02),	// Startwert B11, weil TLE4905 low aktiv
  enc_counter(0),	// Zähler
  direction(0),		// Richtungsanzeige  +1 / -1
  Phase_A(1),     	// default 1, weil TLE4905 low aktiv
  Phase_B(1)		// default 1, weil TLE4905 low aktiv
{ }	

// ab hier Scopes/Bereichsoperator ::
void GrayEncoder::encode()  
{
  int i = 0;
  
  Phase_A = (*PORT >> PinA & 1);  // einzelnes Bit heraus fischen
  Phase_B = (*PORT >> PinB & 1);
    
  if( Phase_A )  {
    i = 1;
  }
  
  if( Phase_B )  {
    i ^= 3;           // convert gray to binary
  }
  
  i -= enc_last;      // difference new - last

  if( i & 1 )  {                 // bit 0 = value (1)
    enc_last += i;               // store new as next last
    enc_counter += (i & 2) - 1;  // bit 1 = direction (+/-), Zähler
    direction = (i & 2) - 1;     // Richtungsanzeige (+1 / -1)
  }
  
}

ist auch eine Initialisierung die eine Deklaration beinhaltet.

Das wird aber erst ausgeführt wenn der Konstruktor-Körper aufgerufen wird! Zu dem Zeitpunkt existieren die Variablen schon. Das heißt Konstanten oder Referenzen sind schon fest und können nicht mehr geändert werden. Und wenn deine Klasse andere Objekte enthält wurde schon deren Konstruktor aufgerufen, was ganz schlecht ist (da gab es eine Threads in letzter Zeit wo sich Leute gewundert haben wieso sie sie Objekte nicht erst im Konstruktor initialisieren können).

Du sagst, die Variablennamen kann man gleich ziehen, der Compiler weis was wohin gehört?

Ja. Da mit den unterschiedlichen Namen kann man sich sparen.

Wobei man es sich auch bei der einfachen Initialisierung sparen kann:

Test(byte p);
{
   this->p = p;
}

Wenn ich hier drin eine Variable vergesse zu initialisieren, dann hat sie einen Zufallswert?

Ja.

Alternativ, in C++11 kann man Variablen auch direkt im Header initialisieren. Dann kann man den Konstruktor für Variablen lassen die wirklich vom Benutzer gesetzt werden. Geschmackssache.

Und ganz wichtig, die Deklaration bestimmt die Initialisierungsreihenfolge, nicht die Liste.

Ja. Sehr wichtig. In deinem Fall ist es egal, aber wenn man mit anderen Objekten arbeitet und diese voneinander abhängen kann das zu ganz gemeinen und schwer auffindbaren Fehlern führen