Hallo, ich versuchte vergebens nach einer Lösung für mein Problem . Ich
benutze einen ATMEGA als Webserver und versuche gerade die HTML Seiten
auf den Flash zu Packen und die im Compiler in eine .cpp Datei
auszulagern.
Mir fehlt es eigentlich schon an den Ansätzen was man machen kann.
Wäre es möglich nach dem Beispiel im Anhang ? ( funktioniert so nicht)
Hauptfile->
server.print(Website.Main()); // in Main befindet sich die Website als
String
.h
Das kann nicht funktionieren.
Nur weil du Text von einer Stelle an eine andere verschiebst, entbindest
du dich ja nicht von den Regeln deiner Programmiersprache.
ein #include macht nichts anderes, als die Zeile mit dem #include durch
den Inhalt der angegebenen Datei zu ersetzen.
Wenn du also zb schreibst
1
voidfoo()
2
{
3
digitalWrite(LED,HIGH);
4
}
dann kannst du diesen Programmtext in einzelne Dateien aufteilen. Zum
Beispiel
1
// Datei1.h
2
voidfoo()
1
// Datei2.h
2
{
1
// Datei3.h
2
digitalWrite(LED,HIGH);
1
// Datei4.h
2
}
jetzt hast du 4 Dateien erzeugt: Datei1.h bis Datei4.h
Jede davon ethält etwas Text.
Wenn du in deinem CPP File dann zb schreibst
1
voidbar()
2
{
3
}
4
5
#include"Datei1.h"
6
#include"Datei2.h"
7
#include"Datei3.h"
8
#include"Datei4.h"
9
10
...
dann ersetzt der Präprozessor jede #include Zeile mit dem Inhalt der
angegebenen Datei. Als Ergebnis, nach dieser Ersetzung, entsteht
1
voidbar()
2
{
3
}
4
5
// Datei1.h
6
voidfoo()
7
// Datei2.h
8
{
9
// Datei3.h
10
digitalWrite(LED,HIGH);
11
// Datei4.h
12
}
13
14
...
also wieder die ursprüngliche Fuktion in Textform. Und erst dieses
Zwischenergebnis geht dann zum eigentlichen Compiler. Dem Präprozessor
ist es dabei gleichgültig welcher Text da in der angegebenen Datei
steht. Der kümmert sich nur darum, dass die #include Zeile mit dem
Dateiinhalt ersetzt wird. Mehr aber auch nicht. D.h. das, was nach
diesen Ersetzungen entsteht, muss selbstverständlich wieder den Regeln
deiner Programmiersprache entsprechen. Für den eigentlichen Compiler ist
es so, als ob da nie ein #include gestanden hätte, sondern dieser Text
von dir schon immer dort hingeschrieben worden wäre.
Ein #include macht also nicht irgendetwas magisches, sondern einfach nur
eine Textersetzung, wobei der Ersatztext aus einer anderen Datei kommt.
Solange du also nicht in eine einzigen CPP Datei beschreiben kannst, was
du eigentlich erreichen möchtest, bringt dir ein #include nichts. Ein
#include ist einfach nur eine Textaufteilung, so dass man beim
Bearbeiten der Quelltexte nicht immer einen Wust von Text vor sich im
Editor hat. Aber mehr steckt nicht hinter einem #include.
Und BTW:
Wie auch ganz gross am oberen Rand der Seite steht, ist das Forum
"Projekte und Code" dafür gedacht, seine fertigen Projekte bzw.
funktionierende Codestücke von (vermutetem) allgemeinem Interesse zu
präsentieren. Es ist nicht dazu gedacht allgemeine Fragen zu stellen.
Verschoben.
nicht funktioniert bzw. was daran falsch ist (nämlich so richtig
grundlegend falsch), dann solltest du erst mal deine Programmiersprache
wenigstens in den Grundzügen lernen. Denn dann fehlt es praktisch an
allem was du eigentlich wissen solltest um ein reales Projekt anzugehen.
Also:
Wie schreibst du dein Programm, wenn du die Seite NICHT in eine andere
Datei ausgelagert hättest?
Das ist dein Ausgangspunkt.
Dann nimmst du den relevanten Textteil aus diesem ursprünglichen
Programm-Quelltext so wie er ist her (in deinem Fall wohl der HTML
Text), steckst ihn in eine eigene Datei (die muss auch nicht *.h
heissen, dem Präprozessor ist das egal wie die Datei heisst, der ersetzt
nur Dateiinhalte) und stellst an die Stelle, an der der Text
ursprünglich gestanden hat einen entsprechenden #include auf genau diese
Datei.
Aber syntaktisch hat sich nichts geändert. Alles was du getan hast, ist
einen Teil des originalen Programmtextes aus Wartbarkeitsgründen in eine
eigene Datei zu verschieben. Das ändert aber nichts daran, dass im
Endeffekt, nachdem alle #include wieder aufgelöst wurden, wieder der
originale Programmtext entstehen muss.
Das war mir davor schon klar , dass es so nicht funktionieren würde. Nur
irgendwie muss ich das Problem doch beschreiben ich habe ja auch dazu
geschrieben das es so nicht funktioniert.
@Peter II
Mit den Konsolen befehlen bin ich soweit noch nicht vertraut
, ich finde dazu keine Beispiele wie ich das umsetzen kann . Vor allem
wie sag ich später dem linker genau wann er dieses "object file"
einsetzen muss ?
Soweit ich dir folgen kann sollte ich diese HTML in eine HEX file
umwandeln welches schon in dem Format ist wie es dem ATMEGA übergeben
wird...
lange Rede kurzer Sinn, ich hab gerade nach einem Beispiel gesucht oder
irgendwie etwas wo jemand sowas ähnliches versucht und bin nicht fündig
geworden.
Könntest du mir dabei bitte weiter helfen ?
Gruß
Jey schrieb:> Das war mir davor schon klar , dass es so nicht funktionieren würde. Nur> irgendwie muss ich das Problem doch beschreiben ich habe ja auch dazu> geschrieben das es so nicht funktioniert.
Na ja.
Aber das muss auch dir klar sein, dass zwischen
1
server.print("hallo");
und
1
voidfoo()
2
{
3
"hallo";
4
}
5
6
...
7
8
server.print(foo());
ein gewaltiger Unterschied besteht.
die Methode 'print' des Server Objektes erwartet einen String. Nämlich
den String, den sie ausgeben soll. Wo dieser String herkommt, ist der
Funktion egal. Den kann man direkt angeben (wie im Beispiel), oder den
könnte auch eine Funktion lieferb.
Die Funktion foo() liefert aber keinen String. Als void Funktion liefert
die erst mal gar nichts. Innerhalb dieser Funktion existiert da so eine
seltsame String Konstante, mit der aber weiter nichts gemacht wird.
Jey schrieb:> Könntest du mir dabei bitte weiter helfen ?
nicht wirklich. Ich arbeite mit make, dafür steht auch das Beispiel auf
der verlinkten Webseite da.
Dort steht auch das dabei eine *.h erzeugt wird, damit kann man dann auf
den Inhalt zugreifen.
Wenn das Studio auch so ein Makefile nutzt, kann man html als binay
einfach im Projekt hinzufügen.
Oh Mann.
Immer wieder dasselbe Trauerspiel mit den Arduino Leuten.
Also. Wie programmierst du sowas ohne Gedanken daran zu verschwenden,
das HTML Zeugs in eine andere Datei zu verfrachten.
na zb so
1
char*mainTxt=
2
"<html>"
3
"<body"
4
" hallo world"
5
"</body>"
6
"</html>"
7
;
8
9
10
....
11
12
server.print(maintxt);
was also ist zu tun, wenn der HTML Text in eine Datei namens 'main.inc'
auszulagern ist?
main.inc
1
"<html>"
2
"<body"
3
"halloworld"
4
"</body>"
5
"</html>"
1
char*mainTxt=
2
#include"main.inc"
3
;
4
5
....
6
7
server.print(maintxt);
Besser gehts in C++ erst mal nicht. Wenn man die zugegeben umständlichen
" im HTML loswerden will, dann geht nur der Trick, den Text erst beim
Linken einzuschleusen. Aber sobald der Text durch den Compiler muss,
müssen die " sein.
@Karl Heinz
ich will hier nichts los treten danke für deine Antwort aber ich hab
doch schon geschildert das ich damit nur zeigen wollte was ich vor habe
weil ich keinen Ansatz für die Umsetzung gefunden habe.
@Peter ich kann dir gerade nicht folgen.
Ich bin nicht so erfahren, ich war der Meinung das jeder Compiler so ein
Makefile benutzt irgendwer muss dem Linker doch die Befehle erteilen ?
Mit welcher Umgebung arbeitest du dann ? Oder nur einfach mit dem
Crosscompiler ?
Jey schrieb:> @Peter ich kann dir gerade nicht folgen.> Ich bin nicht so erfahren, ich war der Meinung das jeder Compiler so ein> Makefile benutzt irgendwer muss dem Linker doch die Befehle erteilen ?
nein muss nicht, die IDE (z.b. Visual Studio) kann selber den Compiler
und linker aufrufen.
> Mit welcher Umgebung arbeitest du dann ? Oder nur einfach mit dem> Crosscompiler
einfacher Editor - für meine kleinen Projekte lohnt sich eine IDE nicht.
Meist nevt mich nach eine weile die ganze "Unterstützung" nur.
@Karl Heinz
erst mal dank aber irgendwo muss man einfach mal anfangen ....
"
Besser gehts in C++ erst mal nicht. Wenn man die zugegeben umständlichen
" im HTML loswerden will, dann geht nur der Trick, den Text erst beim
Linken einzuschleusen. Aber sobald der Text durch den Compiler muss,
müssen die " sein
"
Mit Notepad++ sind die "" gleich eingefügt.
Aber wie würde es funktionieren ?
Gruß
Peter II schrieb:> nein muss nicht, die IDE (z.b. Visual Studio) kann selber den Compiler> und linker aufrufen.
Wenn ich richtig informiert bin, erzeugt sie sich selbst ein
"temporäres" Makefile und arbeitet dieses dann ab. Beim Atmel Studio,
was ja auf Grundlage des Visual Studio arbeitet, habe ich das mal
gelesen. Ist das nicht richtig?
npn schrieb:> Peter II schrieb:>> nein muss nicht, die IDE (z.b. Visual Studio) kann selber den Compiler>> und linker aufrufen.>> Wenn ich richtig informiert bin, erzeugt sie sich selbst ein> "temporäres" Makefile und arbeitet dieses dann ab. Beim Atmel Studio,> was ja auf Grundlage des Visual Studio arbeitet, habe ich das mal> gelesen. Ist das nicht richtig?
Im Prinzip hast du schon recht.
Aber es gibt auch die Möglichkeit diesen Automatismus abzuschalten und
sein eigenes makefile zu benutzen.
Dann allerdings sollte man schon wissen was man tut.
Zudem gibt es bei der Basis des Atmel-Studios, welches ja bekanntlich
auch Visual Studio von MS aufsetzt, auch noch die Möglichkeit, seine
eigenen Aktionen für diverse Filetypen zu vereinbaren, bzw.
benutzerdefinierte Teile in die generierten make-Kommandos
einzuschleusen.
Auch da sollte man wissen was man tut.
Karl H. schrieb:> npn schrieb:>> Peter II schrieb:>>> nein muss nicht, die IDE (z.b. Visual Studio) kann selber den Compiler>>> und linker aufrufen.>>>> Wenn ich richtig informiert bin, erzeugt sie sich selbst ein>> "temporäres" Makefile und arbeitet dieses dann ab. Beim Atmel Studio,>> was ja auf Grundlage des Visual Studio arbeitet, habe ich das mal>> gelesen. Ist das nicht richtig?>> Im Prinzip hast du schon recht.> Aber es gibt auch die Möglichkeit diesen Automatismus abzuschalten und> sein eigenes makefile zu benutzen.> Dann allerdings sollte man schon wissen was man tut.
Na dann bin ich ja beruhigt.
Das mit dem eigenen makefile wußte ich, habe es aber noch nie genutzt.
Danke!
Also in der Arduino-Umgebung geht das sehr effizient mit der
F()-Funktion, z.B.
client.print(F("<hr>Ü&berschift<hr>"));
Vlt. mal analysieren, wie das dort gemacht wird, sich selber so eine
Funktion schreiben und auf AtmelStudio umsetzen. Das Besondere daran ist
wohl, dass diese Funktion bereits beim Compilieren ausgeführt wird ...
ist dann wohl eher als Pragma oder Compileroption zu verstehen.
eigentlich rutsche ich jetzt zum nächsten Problem, fällt mir gerade auf
,
soweit war ich nämlich schon mal der Compiler müsste wissen jetzt kommt
nur ein einfacher Text und so sollte er ihn auch behandeln.
In meinem HTML Code kommt viel Javaskript vor und genauso mal "" oder
irgendwelche anderen Sonderzeichen...leider interpretiert er das dann
falsch.
Kann ich dem Compiler irgendwie mitteilen jetzt kommt ein String und
betrachte den dann auch so ohne mir jedes Zeichen rauszusuchen und zu
kontrollieren zb das ist ein Backslash...es wäre furchtbar nervig jedes
mal aus einem Backslash einen DoppelBackslash zu machen.
Natürlich könnte ich mir jetzt einen kleines Konsolen Programm schreiben
mit dem ich am Schluss die HTML einlese und danach die fertige zurück
bekomme. Aber gehts nicht einfacher ?
@KarlHeinz
Gibts Grenzen in der String länge ?
Gruß
Wenn es nur einmal geschachtelt wird, kannst du alle " in HTML und/oder
Javascript problemlos durch ' ersetzen. Ansonsten unterstützen viele
IDEs auch die Escape-Schreibweise, also \" für ein " innerhalb eines
durch "" eingegrenzten String.
Frank E. schrieb:> Ansonsten unterstützen viele> IDEs auch die Escape-Schreibweise, also \" für ein " innerhalb eines> durch "" eingegrenzten String.
@TO
Das hat mit einer IDE nichts zu tun.
Das ist die in C (und C++) vorgesehene Schreibweise, wie man innerhalb
eines Strings einen " als Zeichen einfügt.
Diese und andere Escape-Sequencen sollte eigentlich jeder kennen, der
einmalig entsprechende Literatur durchgearbeitet hat. Das kommt dort
üblicherweise irgendwo in den ersten 10% des Buches vor.
Womit wir wieder bei meinem Lieblingsspruch sind: Du brauchst Literatur!
Jey schrieb:> Natürlich könnte ich mir jetzt einen kleines Konsolen Programm schreiben> mit dem ich am Schluss die HTML einlese und danach die fertige zurück> bekomme. Aber gehts nicht einfacher ?
Tu das.
Das ist die einfachste Möglichkeit.
Deine HTML Seiten werden sich sicherlich noch ein paar mal ändern und so
ein Aufbereiter ist ja schnell geschrieben.
Gewöhn dich daran, dass man als SW-Entwickler auch schon mal auf
Hilfsprogramme zurückgreifen muss, die man durchaus auch schon mal
selber schreiben muss. Für Textverarbeitung im weitesten Sinne bieten
sich zb awk bzw. sed als Prozessoren an, wenn man nicht selber was
schreiben will.
> Gibts Grenzen in der String länge ?
rein Prinzipiell: je nachdem was auf deinem System ein size_t ist.
In deinem speziellen Programm kann es natürlich sein, dass es eine Länge
gibt, ab der die weiterverarbeitenden Funktionen nicht mehr mitmachen.
Edit:
Das original dieses Postings enthielt den Abschnitt:
Das original HTML File kommt ins Projekt mit dazu, in den Einstellungen
für das generierte File legst du (Atmel Studio) in den Eigenschaften
fest, dass das aufbereitete File aus dem HTML File durch Aufruf deines
Konverters erzeugt wird und auch von ihm abhängt. Das geht natürlich
auch mit einem makefile, wenn du so etwas benutzt.
In Zukunft brauchst du dich dann nicht mehr gross darum kümmern. Du
änderst einfach das original HTML File und Atmel Studio (bzw. make)
kümmern sich darum, dass es entsprechend aufbereitet wird, ehe es dann
zum Compiler geht.
Eine nachträgliche, kurze, Überprüfung meinerseits hat allerdings
ergeben, dass Atmel wohl diese Möglichkeit nicht zur Verfügung stellt,
obwohl das bei der von Atmel benutzten Vorlage, Developer Studio von MS,
eine ganz normale Sache ist.
Die oben verlinkte Lösung mit objcopy ist m.E. die einzig vernünftige.
Wenn Du das deiner IDE nicht beibringen kannst, dann erzeuge doch extern
eine Library (Libraries wird sie ja wohl einbinden können).
Dazu rufst Du einfach für jede .html-Datei objcopy auf und verpackst die
Objektdateien in einer Library:
1
for i in *html
2
do
3
objcopy -I binary -O elf32-avr $i $i.o
4
done
5
6
ar rv libhtmlsite.a *.o
Möglicherweise noch anpassen, daß die Sectionnamen passen (ist im
Artikel beschrieben), falls Du Windows benutzt, mußt Du das Script
anpassen, aber das ist nicht besonders schwierig.
Die Library linkst Du einfach zu deinem Programm und der Käse ist
gefressen.
Jedesmal, wenn Du an den .html-Dateien was änderst, mußt Du halt das
Script laufen lassen, aber Du wolltest ja keine Makefiles... ;)
@Karl Heinz
deine Lösung klingt sehr verlockend.
Zu deiner Antwort zum Thema Software Entwickler.
Ich mache beruflich nichts anderes, meine C /C++ Kenntnisse sind einfach
einwenig eingerostet zu dem bringen die Mikrocontroller schon viele
Eigenheiten mit genauso wenig bin ich es nicht gewohnt mich damit
rumzukämpfen wie etwas gelinkt wird.
Ich bin im Automotiv für die großen Autohersteller tätig , ich kämpfe
mich daher nur mit irgendwelchen Skripten rum die den Anschein machen
sie wären vor 200 Jahren entwickelt worden aber dafür hantieren die dann
schon mit Datenbanken...
Fortschrittlicher sind dann eher schon die SPS n die Hochsprachen wie ST
verstehen und sonst Graphisch programmiert werden.
Früher hat man wenn wir was gebraucht haben immer kleine Consolen
Programme geschrieben jetzt löst man aber alles mit VBA und EXEL wenn
man was anpassen will...
Leider leider findet man zum Thema MAKEfile ect kaum was zu ATMEL
STUDIO...
Verbesster mit wenn ich falsch liege, ich denke ATMEL Studio kann mit so
ziemlich allem arbeiten bzw. man kann es einbinden aufrufen ?
Gibts nicht einfach einen editor mit dem man Abläufe programmieren kann,
ich stelle mir das jetzt vor wie als wenn ich ein Macro für Exel in VBA
schreiben würde
@Frank Esselbach
"
Wenn es nur einmal geschachtelt wird, kannst du alle " in HTML und/oder
Javascript problemlos durch ' ersetzen. Ansonsten unterstützen viele
"
Was verstehst du unter geschachtelt ?
Jey schrieb:> Leider leider findet man zum Thema MAKEfile ect kaum was zu ATMEL> STUDIO...>> Verbesster mit wenn ich falsch liege, ich denke ATMEL Studio kann mit so> ziemlich allem arbeiten bzw. man kann es einbinden aufrufen ?
Leider scheint es aber so zu sein, dass Atmel einige nützliche Dinge aus
dem Developer Studio rausgeworfen hat (Dev Studio von Microsoft ist die
Basis von Atmel Studio). Unter anderem auch die Möglichkeit einen
'benutzerdefinierten Build-Step' für jedes File anzugeben.
Auch die Möglichkeit eines Pre-Build Kommandos bzw. Post-Build Kommandos
scheint es nicht zu geben. Schade
> Gibts nicht einfach einen editor mit dem man Abläufe programmieren kann,> ich stelle mir das jetzt vor wie als wenn ich ein Macro für Exel in VBA> schreiben würde
grundsätzlich könnte man das mit einem make problemlos erschlagen.
Allerdings finde ich auf die schnelle keine Möglichkeit, wie man das
transparent ins Atmel Studio integrieren kann, ohne gleich komplett auf
ein externes makefile umstellen zu müssen.
Damit ich dabei bin, in älteren Versionen konnte man die Abläufe steuern
was die IDE alles so anstellt bis zum fertigen HEX file ?
Und dann hätte man zusätzliche Befehle Kommandos skripte ect. einbauen
können?
Das Makefile steuert also nicht nur wie etwas gelinkt wird ?
Ich hatte mich schon mal vor Monaten versucht mich damit zu beschäftigen
aber dar ich bisher in ATMEL Studio noch nie in die Bredouille gekommen
bin hab ich das alles verworfen.
Jey schrieb:> Das Makefile steuert also nicht nur wie etwas gelinkt wird ?
ein make (bzw. das zugehörige Kommando File - eben das makefile) weiss
nichts von einem Compiler oder einem Linker.
was make macht:
Es hat (in der einfachsten Form) eine Liste von Regeln, die so aussehen
1
zieldatei: quelldatei
2
kommando
Die Bedeutung ist:
sieh dir das Filedatum von 'quelldatei' und 'zieldatei' an. Wenn die
'quelldatei' jünger als die 'zieldatei' ist, dann führe das Kommando
'kommando' aus.
Mehr macht make im Prinzip nicht.
Ob das jetzt dazu benutzt wird, um Object Files aus C-Files zu
compilieren, oder um aus neueren Object Files ein ausführbares Programm
zu linken, ob das benutzt wird um aus einer Datendatei ein Diagramm zu
generieren, ob das dazu benutzt wird um Dateien die irgendwo hin kopiert
werden automatisch auszudrucken, ob du damit automatisch deine Mail ans
NSA weiterleiten willst, ob ... das alles interessiert make nicht. Alles
was make interessiert, das ist ob die angegebene(n) Quelldatei(en)
jünger ist (sind) als die Zieldatei und wenn ja, welche(s) Kommando(s)
auszuführen ist (sind).
Das ist das Grundprinzip von make bzw dem makefile. Alles weitere ist
dann Komfort, mit dem man im makefile arbeiten kann um nicht dauernd
alles wieder neu hinschreiben zu müssen.
ein makefile, das ich vor kurzem auf die schnelle zusammengestoppelt
habe, sieht zb so aus
rangdb (das eigentliche Programm) ist abhängig von rangdb.o, SmartDB.o,
SailDB.o, Parse.o, Calculate.o und Result.o. Ist irgendeine davon jünger
als 'rangdb'm dann wird das Kommando 'g++ rangdb.o SailD.....'
ausgeführt, welches zufälligerweise der Linker ist.
Wo kommt zb SailDB.o her? Auch dafür gibt es eine Regel:
1
SailDB.o: SailDB.cpp SailDB.h SmartDB.h
2
g++ -c SailDB.cpp
SailDB.o ist abhängig von SailDB.cpp, SailDB.h und SmartDB.h. Ist eine
Datei davon jünger als SailDB.o, dann wird das Kommando 'g++ -c
SailDB.cpp' augeführt, weilches zufälligerweise der Compileraufruf ist,
der aus SailDB.cpp eine neue SailDB.o erzeugt, die dann natürlich jünger
als 'rangdb' ist, womit auch diese Regel "feuern" wird, die dann 'ganz
zufällig' den Linker anwirft.
make ist das völlig wurscht, wie die Zusammenhänge sind. Alles was du
als makefile schreiber wissen musst, das ist welches Kommando du auf der
Commandline des Systems ausführen würdest, damit aus der Datei A die
Datei B erzeugt wird. Was es mit diesen Dateien für eine Bewandtnis hat
bzw. was das Kommando genau macht, interessiert make nicht.
alles keine Hexerei und viel weniger geheimnisvoll als viele denken.
hinzuzufügen bleibt nur noch, dass make noch viel viel mehr kann. Aber
um 3, 4 oder 5 Dateien und deren Abhängigkeiten zu jonglieren, braucht
man das alles noch nicht. Das geht locker auch noch so.
D. C. schrieb:> Ich stehe vor dem selben> Problem, was soll das für eine Sprache sein ?
Offenbar die Skriptsprache seiner Shell.
Unter Linux sind die Leute noch daran gewöhnt, wie mächtig eine
Commandline mit einer ordentlichen Scriptsprache sein kann. Ganz im
Gegensatz zu Klickibunti.
D. C. schrieb:> Markus könntest du dazu bitte mehr sagen ?
Ja, das ist ein Shell-Skript.
Geht mit Windows (CMD) auch, bloß nicht so schön. Real programmers don't
use Windows.
1
FOR %%f IN (*.html) DO objcopy -I binary -O elf32-avr %%f %%f.o
Langsam komme ich auf den richtigen Nenner , bzw auf die hintergründe.
Aber wie darf ich mir make genau vorstellen ist das ein Programm ? Wer
gibt die Regeln vor ? Weil nur durch
Result.o: Result.cpp Result.h
wird ja nicht bestimmt wie es das zusammen setzen macht, kennt make die
unterschiedlichen Daten Endungen und weiß was was ist ?
Also das in cpp der Quellcode steht und in der h nur die zb Definitionen
ect..
Gruß
Ich würde gerne jetzt mal Markus sein Beispiel richtig interpretieren
verbessert mich bitte.
> for i in *html> do> objcopy -I binary -O elf32-avr $i $i.o> done>> ar rv libhtmlsite.a *.o
"i" wird eine Shell variablere ( Deklaration ) *html wird der variable i
übergeben
dann kopiere ($ heißt übergebe oder?) $i.o mit dem elf32-avr
objektformat in eine andere Datei und die ist binary ( jetzt wirds müll
) ...
die Variable i erhält als Wert die Dateinamen aller *.html-Dateien im
Verzeichnis.
über diese Liste wird eine Schleife gedreht, für jedes Element (jede
Datei) wird objcopy aufgerufen, das aus der .html-Datei eine Objektdatei
macht.
Nach der Schleife werden alle erzeugten Objektdateien mit ar in eine
Library verpackt.
Ein Makefile ist - wie schon gesagt - die bessere Wahl.
D. C. schrieb:> Wo ich wieder beim Problem bin sowas in Atmel studio umzusetzen. Danke> für eure Hilfe ein wenig licht im Dunklen gibts schon...
Tut mir leid, ich kapier's nicht.
Du wirst doch wohl noch kurz das studio verlassen können, einen Befehl
eintippen und das Fenster wieder wechseln können?
Markus F. schrieb:> Uiuiui. Steile Lernkurve.>
Google hat mir nicht viel sagen können nur-->.
NM ist wie ar ein Programm ."NM soll die Symbol Tabelle ausgeben",
worauf willst du hinaus? Ziel ist es doch die HTML so zu übersetzen das
der linker sie einbauen kann bzw die objektdatei in eine lib einzubauen
die dann über die include# "ichbineineHTML" implementiert wird.
Das Makefile kann ich bis dato ja nicht beeinflussen dar ATMEL STUDIO
alles selber organisiert.
Für mich war eine lib nur immer eine file in der ich Programmcodes
verwalten kann und dadurch mein eigentliches Programm sauber halte.
Das es auch Dynamische lib s gibt weiß ich auch noch, aber bisher hatte
ich sowas noch nie gebraucht. Ich denke aber darauf willst du hinaus ?
Es wäre nett wenn ich mal erfahre worauf du hinaus willst, ein Ratespiel
macht es nicht einfacher für mich, ich will hier nicht zu den
blödschwätzern gehören mich interessiert s ja auch wirklich ;-).
Wie soll dass der Reihenfolge aus aussehen von der html zum linker ?
Dann wüsste ich schon mal besser nach was ich suchen muss.
Schon mal DANKE.
Gruß
Karl H. schrieb:> Besser gehts in C++ erst mal nicht.
Doch, je nach Version der Sprache geht es besser.
> Wenn man die zugegeben umständlichen " im HTML loswerden will, dann geht> nur der Trick, den Text erst beim Linken einzuschleusen. Aber sobald der> Text durch den Compiler muss, müssen die " sein.
C++11 unterstützt raw string literals. Damit kann man so einen String
auch so schreiben:
1
R"(<htmllang="de">
2
<body>
3
hello world
4
</body>
5
</html>)";
Man beachte auch, daß die Anführungszeichen um das de herum nicht
gequotet werden müssen.
Rolf M. schrieb:> C++11 unterstützt raw string literals. Damit kann man so einen String> auch so schreiben:
aber Vorsicht, in JavaScript kommt auch sehr schnell ein )" vor.
D. C. schrieb:>> Wie soll dass der Reihenfolge aus aussehen von der html zum linker ?> Dann wüsste ich schon mal besser nach was ich suchen muss.>
Eigentlich steht schon alles da. Mit dem Script kannst Du die
HTML-Dateien als Objektdateien generieren und sie anschließend mit ar in
eine Library verpacken. Die linkst Du zu deinem Projekt.
Im oben verlinkten AVR-Tutorial (2. Beitrag im Thread) steht, wie Du aus
deinem Programm heraus auf die Texte zugreifen kannst.
Vorgekaut wär' m.E. jetzt genug. Machen mußt Du's aber schon selbst.
Ich hab mich die tage ein wenig mit den Makefiles beschäftigt bzw
allgemein mit der Console. Ich würde jetzt lügen wenn ich sagen würde
das ich durchblicke aber dennoch kleine erfolge waren dabei.
Zum Thema Make, ich habe den Crosscompiler auf meinem Mac installiert,
und eine copy.sh mit der Source von Atmel geschrieben( copy%paste) ;-)
Das Skripte hab ich dann über cd /pfad... aufgerufen und das
funktionierte schon mal mit Make copy.
Es wurde eine kleine Consolen Output erzeugt ich denke das soll eine
Fehlerconsole sein mit
Dominiks-MBP:~ dominikloher$ /Users/dominikloher/Desktop/Html_v1/copy ;
exit;
/Users/dominikloher/Desktop/Html_v1/copy: line 1: test.o: command not
found
/Users/dominikloher/Desktop/Html_v1/copy: line 2: syntax error near
unexpected token `newline'
/Users/dominikloher/Desktop/Html_v1/copy: line 2: ` @echo
Converting $<'
logout
[Prozess beendet]
einzig das $(OBJDIR)/%.o : %.txt habe ich zu
test.o : %.txt angepasst was für mich bedeuten soll das er die Dateo
test.o anlegen soll sofern nicht vorhanden und sie abhängig ist von
.txt.
Kann mir bitte wer helfen ?
Gruß
Schwierige Geburt , zum Schluss bin noch darüber gestolpert dass ich dem
Skript die Endung .sh gab und danach das ich über die Console statt make
das skript mit make -f aufrufen muss. Ob das absolut richtig war weiß
ich nicht aber eine .h und .o wurde erstellt :)
Karl H. schrieb:>> ....>> server.print( maintxt );>> Besser gehts in C++ erst mal nicht. Wenn man die zugegeben umständlichen> " im HTML loswerden will, dann geht nur der Trick, den Text erst beim> Linken einzuschleusen. Aber sobald der Text durch den Compiler muss,> müssen die " sein.
Doch denn es sollte auch gehen wenn man die HTML in ein HEX File
umwandelt und danach dieses HEX file uncludiert.Verbessert mich wenn ich
falsch liege