Arduino IDE LiquidCrystal.h

[Meik J. (tidemic)]

Hallo sehr geehrte Community,

ich beginne mit einer kurzen Einleitung:
Ich arbeite in der Industrie als Betriebstechniker
Schwerpunkt Automatisierung. Dadurch gehört der
Umgang mit SPS(PLC)  zu meinem täglichen Brot!

Vor ca einen 3/4 Jahr habe ich, aus privaten Interesse,
den Entschluss gefasst. Mich seit Jugendtagen (BASIC Interpreter)
mal wieder mit einer anderen Programmiersprache auseinander zusetzen.
Die Wahl viel auf C++. Die kleinste Hürde war sehr schnell genommen.
Der Erwerb von Fachliteratur:
Galileo Computing Einstieg in C++
siehe oben        Schrödinger programmiert C++
Hanser            C++ für Spiele Programmierer

Ich habe durch diese Bücher, Microsoft Visual Express und Zeit(viel 
Zeit).
Mir ein Solides Wissen angeeignet.

Aber immer nur Übung ohne weiteren Sinn zu schreiben.
Bereitet mir nur bedingt Vergnügen.
Aber wozu hat man Freunde! Meiner beauftragte mich eine Aquarium 
Controller
zu fertigen. SPS wäre da viel zu teuer.
Da bin ich auf den Arduino gestoßen. Super, meine C++ Theorie umsetzten.

Ich will jetzt nicht das Produkt kritisieren. Das steht mir auch gar 
nicht zu
der Erfolg gibt im ja Recht! SUPER GERÄTE

Aber ich gerate doch oft ins stolpern.
Nur eine Beispiel:
Templates bekomme ich nur INLINE in der X.h deklariert und definiert.
Und nicht getrennt Deklaration in x.h Definition in x.cpp.

Bei Problemen schlage ich dann erneut in der Fachliteratur
nach. Und übernehme den Code aus dieser eins zu eins.
Wobei die Arduino IDE diese meistens mit Fehlermeldung quittiert.
Wärend Microsoft IDE diese umsetzt.

Ich wollte hier nur mal eine von mehreren Erfahrungen aufführen.
Und mit dem Template Problem kann ich auch sehr gut leben.

Eine Lösung hätte ich ganz gerne für folgendes Problem:

Ich möchte in einer Screen.h/.cpp Methoden(Funktionen) von 
LiquidCrystal.h
nutzen.
zB in der
Screen.cpp lcd.print(xy)
In der Screen.h ist die LiquidCrystal.h inkludiert.
Habe auch andere Wege probiert.

Bei Serial.print oder EEPROM.h hatte ich keine solche Probleme.

Über Hilfe oder Antwort würde ich mich sehr freuen.

Gruß Meik

[Murrr (Gast)]

Und was hat das in der Projekt/Codesammlung zu suchen?

[Dr. Sommer (Gast)]

Meik Juenke schrieb:
> Aber ich gerate doch oft ins stolpern.
> zB Templates bekomme ich nur INLINE in der X.h deklariert und definiert.
> Und nicht getrennt Deklaration in x.h Definition in x.cpp.
Ja das ist normal, das muss so.

Meik Juenke schrieb:
> In der Microsoft IDE lief es auch ohne Probleme.
Kann nicht sein. Es gibt nur einen einzigen Compiler der das kann, und 
zwar Comeau. Daher macht das auch keiner, und alle templates landen 
komplett im Header... Das sollte aber auch im Buch stehen.

[Dr. Sommer (Gast)]

PS: Behelfsmäßig kann man die Implementation einfach in einen 2. Header 
packen und den am Ende des 1. #include'n.

[Meik J. (tidemic)]

Danke für die Antworten
@ Dr. Sommer
Ich möchte jetzt keine Grundsatzfrage zu irgendwelchen IDE's starten!
Des weiteren werde ich hier keine Fachliteratur zitieren.

//Projekt.ino

#include"Screen.h"

/*
 .
 .
 .
*/

//Screen.h
#include<LiquidCrystal.h>

/*
.
.
.
*/

Das funzt nicht..egal wie rum.

Oder welchen Ansatz hattest du?

[Informatiker (Gast)]

Meik Juenke schrieb:
> Oder welchen Ansatz hattest du?
Den Standard-Ansatz den alle benutzen:

Header.h:
.. Definition der Funktions/Klassen-templates ...

main.cpp:
#include <Header.h>

.. Nutzung der templates...

Aufruf des Compilers dann auf die main.cpp.

[Karl H. (kbuchegg)]

Meik Juenke schrieb:

> Das funzt nicht..egal wie rum.
>
> Oder welchen Ansatz hattest du?


Lass dich von einem ganz einfachen Gedankengang leiten:
C++ kennt keinen Projektgedanken im Compiler.
D.h. wenn der Compiler eine Source Code Datei xyz.cpp compiliert, dann 
blickt er nicht links und nicht rechts. Was in den Dateien ijk.cpp oder 
abc.cpp steht, interessiert ihn nicht die Bohne. Jede CPP Datei wird 
unabhängig von allen anderen compiliert.

Daher muss jede derartige Einheit, man spricht auch von einer 
Compilation Unit, in sich vollständig sein! Und zwar von oben nach 
unten. Denn genau so liest der Compiler den Code: von oben nach unten. 
Und zwar nur ein einziges mal.

Wenn du das als Grundgedanken beherzigst und dich danach richtest, dann 
fallen viele Probleme weg.

Das du in deiner IDE so etwas wie ein Projekt hast, in dem alle zum 
Projekt gehörenden Dateien gesammelt und verwaltet werden; dass deine 
IDE Befehle hat um dir zb die Definitionen oder Deklarationen von 
verschiedenene Dingen rauszusuchen, das ist eine nette Eigenschaft deine 
Entwicklungsumgebung. Nur interessiert das den Compiler nicht im 
geringsten. Der kriegt letzten Endes von der IDE den Auftrag, die Datei 
xyz.cpp zu compilieren. Und genau das und nur das macht er dann auch.


Und PS:
'funzt nicht' ist keine Fehlermeldung.
Der Compiler wirft sicher nicht raus
** Error 2003 (23) ** does not funzen.

Jeder Compiler gibt eine ordentliche Fehlermeldung raus, die zwar 
manchmal etwas missverständlich ist aber die Dinge sind besser geworden. 
Ich würde mal sagen in mehr als 80% aller Fälle enthält der Text der 
Fehlermeldung zumindest einen zielführenden Hinweis.

[Meik J. (tidemic)]

Moin Karl Heinz,
danke für deine Antwort. Und ja du hast Recht, meine Problem Darstellung
ist mangelhaft. Wahrscheinlich sehe ich den Wald vor lauter Bäumen 
nicht.

Code aufs nötigste gekürzt:

//sketch.ino
#include"Screen.h"//Der Präprozessor fügt die Screen.h(Deklaration) ein

void setup()
{
 lcd.begin(16,2);
 lcd.clear(); 
}

void loop()
{
  
}

//Screnn.h
#include"Arduino.h"//Der Präprozessor fügt die Arduino.h(Deklaration) ein
#include <LiquidCrystal.h>//Der Präprozessor fügt die LiquidCrystal.h ein

#ifndef SCREEN_H//Präprozessor überprüft doppeltes Einfügen
#define SCREEN_H

LiquidCrystal lcd(4,5,6,7,8,9);//Erzeugen des Objektes lcd 

class Text//Klassen Deklaration
{ 
  public:
  void out(String);
};

#endif

//Screen.cpp
#include"Screen.h"//Der Präprozessor fügt die Screen.h(Deklaration) ein

void Text::out(String In)//Definition Methode der Klasse Text
{
  lcd.setCursor(0,0);
  lcd.print(In);
}

Fehlermeldung:

In file included from LCD_Prob.ino:3:
Screen.h:10: error: 'LiquidCrystal' does not name a type
LCD_Prob.ino: In function 'void setup()':
LCD_Prob:10: error: 'lcd' was not declared in this scope

Das erzeugt keine Fehlermeldung:

//Sketch2.ino
#include <LiquidCrystal.h>
LiquidCrystal lcd(4,5,6,7,8,9);

void setup()
{
  lcd.begin(16,2);
  lcd.clear();
}

class Text
{
  public:
  void out(String In)
  {
    lcd.setCursor(0,0);
    lcd.print(In);
  };
 };
  
void loop()
{
 String Hallo = "Hallo";
 Text Test;
 Test.out(Hallo); 
  
}

Mein Amateur Verständnis ist folgendes->
Einfach ausgedrückt:
Der Präprozessor setzt unter anderen, bedingt einfach den Code(Text)
der Inkludierten Module (Seiten) mit auf betreffende Module (Seite)
Und der Compiler arbeitet übersetzt Modul für Modul. Von oben nach unten 
ab.
Erst der Linker fügt dann die einzelnen Module zu einem Programm 
zusammen.
Der Linker schaut also rechts und links!
Wie du das wohl auch meintest.

mfG Meik