Das ist das Problem, wenn man "fremden" Code übernimmt, egal ob er von
anderen Menschen oder der KI kommt. Man kommt möglicherweise schnell zu
Ergebnissen, versteht aber nicht, was passiert.
Es kommt auch darauf an WIE man anfängt. Ich (stellvertretend für die ganze Generation) hatte damals eine 2 in den Akkumulator geladen, eine 3 addiert und mich gefreut dass ich eine 5 zurück bekam. Und auch gleich gelernt, dass ein carry flag durchaus seine Bestimmung hat und einem den Tag versauen kann wenn es vor einer Addition irrtümlich gesetzt ist.
Heute wird als erste Aufgabe ohne jegliche Programmierkenntnisse gleich einmal eine Home-Automation Steuerung versucht. Mit einer KI-Lösung welche - wie in diesem Fall - dann zB. erst einmal einen off by one Patzer einbaut den ein Anfänger niemals finden würde.
Lernen ist immer noch mühsam, aber der Erfolg ist dann um so süßer.
Also ich würde einem Anfänger ganz sicher nicht die Eclipse IDE
empfehlen, um nur ein negatives Beispiel zu nennen. Da muss man viel zu
viel machen, um es ans Laufen zu bringen.
Zustimmung.
Diejenigen welche sich auf der Kommandozeile wohlfühlen reicht VI-lleicht schon ein einfacher Editor aus. ;-)
Ansonsten, etwas sehr Einfaches, Grafisches. Geany wäre Anfängertauglich, hat schon eingebaute Möglichkeiten zum Kompilieren(F8) und Linken(Ctrl-F8) und kann darüber hinaus auch den GDB Debugger handhaben. Zum Üben und für kleine Quickies reicht das alle Male.
Es geht noch viel primitiver zu beim Einbauen von Fehlern.
So wollte ich gestern den "serial monitor" aktivieren. Funktionierte nicht.
Denn bei Arduino ist Groß- und Keinschreibung crucial. (Das steht auch im Tutorial.)
Das "S" von Serial Monitor war klein geschrieben. Der Fehlerkommentar sagt aber nicht:
"Schreib das "s" gefälligst groß".
Na sowas. Bei HTML gibt es sowas wie "Parser", die noch viel gravierendere Syntaxfehler weitestgehend automatisch ausbügeln. Manchmal ist Arduino eben doch irgendwie pingelig.
Es geht noch viel primitiver zu beim Einbauen von Fehlern.
So wollte ich gestern den "serial monitor" aktivieren. Funktionierte
nicht.
Denn bei Arduino ist Groß- und Keinschreibung crucial.
Verstehe ich nicht. Den Serial Monitor klickt man an. Dazu muss man nichts eintippen.
Meinst du das Serial Objekt im Quelltext? In der Programmiersprache ist (wie in fast allen anderen auch) alles case sensitive.
Es geht noch viel primitiver zu beim Einbauen von Fehlern.
So wollte ich gestern den "serial monitor" aktivieren. Funktionierte
nicht.
Denn bei Arduino ist Groß- und Keinschreibung crucial. (Das steht auch
im Tutorial.)
Das "S" von Serial Monitor war klein geschrieben. Der Fehlerkommentar
sagt aber nicht:
"Schreib das "s" gefälligst groß".
Wenn man die Arduino IDE installiert, dann sind erst einmal nahezu sämtliche Warn- und Fehlermeldungen ausgeschaltet. Das würde ja auch nur verwirren und die Ästhetik beeinträchtigen. Kann man aber in einem Menü einschalten. Dann tauchen zumindest einige Warnungen auf. Leider auch schon solche, die da gar nicht auftauchen sollten.
Schlimmer wird's dann aber, wenn man einige seiner eigenen, langjährig erprobten, erweiterten Compiler-Warnungen dazu nimmt. Dann ersäuft man plötzlich in einem Meer von Meldungen. Nicht etwa die in seinem eigenen Code, nein, die Warnungen kommen alle aus der eigentlichen Arduino Basis. Was man da an extrem schlampig zusammen gehauenem Code sieht, ist gelinde gesagt eine Frechheit.
Mich würde mal interessieren, wie lange die Arduino Macher daran gearbeitet haben ein Set von Compiler Flags zusammen zu stellen, das ihren eigenen, grausamen Code bestmöglich übertüncht.
Nun könnte man sagen, sind ja nur Warnungen. Aber, die eigenen gehen dann in der Masse unter. Wenn jemand ständig Feuer,Feuer schreit, … Ihr kennt den Spruch.
Leider hast du vergessen die Meldungen klar zu benennen.
Nein, das habe ich nicht 'vergessen'. Die kann jeder selbstständig nachvollziehen wenn er die letzte gültige (und immer noch zum Download angebotene) 1.8.19 installiert.
Fehler kannst du bei github selber korrigieren.
Wozu? Ich benutze Arduino nur (im Sinne von ausschließlich), wenn ich im Bekanntenkreis bei Problemen um Hilfe gebeten werde.
Bei mir kommen keine Meldungen, auch bei scharfer Einstellung.
Lies und vor allem Verstehe was ich geschrieben habe!
Aber extra für dich ein kleines Beispiel:
1
for(uint8_tx=-5;x<=5;x++)
2
{}
Wird von der Arduino IDE aufgrund von fehlendem -Wsign-conversion Flag ohne die geringste Warnung kompiliert. Hier wird das kleine ›u‹ vor int8_t zu einer wunderbaren Anfänger Falle.
Schaltet man jedoch dieses essentielle Warnflag ein, wird in:
wiring_analog.c sechs mal gewarnt
CDC.cpp zweimal gewarnt
IPAddress.cpp einmal gewarnt
Hinzu kommen nun noch (teilweise unzählige) Meldungen in Tone.cpp, Print.cpp, Stream.cpp, WMath.cpp, WString.cpp, USBCore.cpp, …
Ich habe hier dann mal aufgehört.
Also unterlasse bitte dein haltloses Geschwätze und überprüfe es selbst. Falls es dir überhaupt darum ging, was ich bezweifele.
Add:
Der hier ist auch noch schön: Obwohl ein C++11 zum Kompilieren explizit vorgegeben wird, wird im
Arduino code teilweise C++14 Funktionalität verwendet.
Schlimmer wird's dann aber, wenn man einige seiner eigenen, langjährig
erprobten, erweiterten Compiler-Warnungen dazu nimmt. Dann ersäuft man
plötzlich in einem Meer von Meldungen.
Nun muß man allerdings sagen, daß der g++ bezüglich solcher Fehlermeldungen und Warnungen recht... gesprächig ist. :-)
Die Nutzung von binären Konstanten würde ich denen allerdings nicht als Mangel ankreiden. Der Code ist für den gcc geschrieben, er kann es und es funktioniert. Es macht den Code an einigen Stellen besser lesbar. Ich nutze diese Erweiterung seit ich denken kann - auch mit anderen C Compilern. Um 2000 herum war das schon ein beinahe selbstverständliches Feature. Hat irgendwer gesagt, dass Arduino keine gcc Erweiterungen nutzen darf?
Über 400 Beiträge um ein Programm auf einen nano zu bekommen, das ist neuer Rekord schätze ich... Wahnsinn... aber schön dass es noch so viel Geduld gibt...
Über 400 Beiträge um ein Programm auf einen nano zu bekommen, das ist
neuer Rekord schätze ich... Wahnsinn... aber schön dass es noch so viel
Geduld gibt...
Leseverständnis würde dir gut tun. Das Programm ist schon lange auf seinem Nano drauf.
Schade, dass die Warnung nicht von -Wall mit eingeschlossen ist.
Es gibt eine stattliche Anzahl Warnungen welche alle nicht bei -Wall -Wextra -pedantic eingeschlossen sind. (Aber darüber können die Compiler-Spezialisten sicher viel besser referieren. Es mag sogar gute Gründe geben.)
Was im Arduino Umfeld wenig bringt.
Dort tut man sowas in der platform.local.txt
Ja selbstverständlich, wäre ja auch zu einfach wenn man's in der IDE machen könnte.
Muss man diese Datei tatsächlich (als root) tief in die Arduino Verzeichnisstruktur (›/opt/arduino-1.8.19/hardware/arduino/avr/‹) einmassieren, oder kann man das vielleicht doch lokal machen? Habe da leider keine zielführenden Informationen finden können.
Muss man diese Datei tatsächlich (als root) tief in die Arduino
Verzeichnisstruktur (›/opt/arduino-1.8.19/hardware/arduino/avr/‹)
einmassieren, oder kann man das vielleicht doch lokal machen? Habe da
leider keine zielführenden Informationen finden können.
Tief, ja.
Der root Zugang sollte sich vermeiden lassen, wenn man die Installation portable macht.
Verstehe ich nicht. Den Serial Monitor klickt man an. Dazu muss man
nichts eintippen.
Das Programm im Bild.
Selbiges per Hand eingetippt, aber
in Zeile 3 und 8 "S" (serial) klein nicht groß (Serial).
Dann kommt eine für den Anfänger nicht leicht zu verstehende Fehlermeldung.
Das ist aber sehr leicht zu beheben. Da macht es richtig "klick" oben im Denkorgan.
"Schau doch gefälligst richtig hin, was in der Vorlage genau steht..." :-)
Ob eine IDE gut oder schlecht ist hängt nun wirklich nicht davon ab, wie
einfach sie sich installieren läßt.
Für einen Anfänger hängt es davon ab.
Sorry, wer nicht in der Lage ist die Entwicklertools (im weitesten Sinne) zu installieren, sollte unbedingt darüber nachdenken, ob Softwareentwicklung für ihn die richtige Spielwiese ist.
Mittlerweile ist die Installation der Tools so einfach, daß das jeder hin bekommen sollte. Worin besteht die Schwierigkeit ein Setupprogramm unter Windows auszuführen und gegebenenfalls dabei ein paar Fragen zu beantworten. Wenn man mit den Fragen nichts anzufangen weis (was schon bedenklich ist, s.o.), dann nimmt man die Voreinstellung des Installeres, denn diese sind oftmals sinnvoll. Für MacOS und Linux gilt ähnliches, denn auch da sind die Programme in den Paketen so geschnürt, daß man am Ende eine lauffähige Entwicklungsumgebung hat.
Einen Installer ausführen sollte
wohl jeder können, der programmieren will.
Also ich würde einem Anfänger ganz sicher nicht die Eclipse IDE
empfehlen, um nur ein negatives Beispiel zu nennen. Da muss man viel zu
viel machen, um es ans Laufen zu bringen.
Die Zeiten wo man bei Eclipse viel machen muß, um die IDE ans Laufen zu bekommen, sind lange vorbei. Das Einzige was man tun muß, ist den richtigen Installer auszuwählen der zur vorgesehen Aufgabe passt. Wenn ich z.B. Embedded machen möchte, dann tue ich halt gut daran das Paket "Eclipse IDE for Embedded C/C++ Developers" zu installieren. Da sind dann auch alle Basics dabei die ich für Embedded brauche.
Gerade mal ausprobiert und die aktuelle Eclipseversion für MacOS herunter geladen. Download und Installation waren in 2 Minuten erledigt und nach ein paar Sekunden wurde das Grundgerüst des ersten C-Projektes angezeigt. Auf "Build Project" geklickt und voila, Projekt compiliert.
Bei Windows oder Linux wird es ähnlich einfach funktionieren, lediglich die Installation könnte etwas länger dauern, weil dort die Dateien in die passenden Verzeichnisse kopiert werden müssen. Das geht beim Mac recht fix weil man da das Image (.dmg Datei) einfach nach Programme zieht. Also wer das nicht hinbekommt sollte sich ein neues Hobby suchen.
Viel mehr Probleme dürfte ein Anfänger mit den vielen Features haben die eine moderne IDE bietet. Da muß man sich wirklich erst mal einarbeiten.
Wenn es bei Arduino bleiben soll, dann spricht nichts dagegen die Arduino IDE zu installieren. Die ist wirklich einfach und auch ein Anfänger sollte da nicht die Übersicht verlieren. Wenn man dann halbwegs sattelfest ist und sein Portfolio erweitern möchte sollte man über eine andere IDE nachdenken. Da ist dann u.a. Visual Studio Code eine durchaus gute Alternative, da man damit auch die mit der Arduino IDE erstellten Sketche weiter führen kann. Zudem ist VS Code durch die vielen Plugins auch recht universell einsetzbar. Ich nutze es neben Embedded auch noch für Python, PHP und Java Script. Eine Übersicht was mit VS Code so anstellen kann gibt es hier https://marketplace.visualstudio.com/vscode.
Ich mache mittlerweile mit VS Code recht viel, weil ich damit verschiedene Aufgaben mit einer IDE erledigen kann und die Bedienung dabei immer gleich ist.
Das mag jeder anders sehen und das ist auch nur ein Vorschlag von mir. Wer mit anderen Tools glücklich ist soll diese benutzen. Am Ende zählt das Ergebnis, wie man dahin kommt ist dabei nicht relevant. Es gibt auch viele Entwickler die auf die klassische Methode setzen, ihren Lieblingseditor benutzen und den Buildprozess dann im Terminal mit den passenden Tools durchführen.
Verstehe ich nicht. Den Serial Monitor klickt man an. Dazu muss man
nichts eintippen.
Nur das Anklicken des Serial Monitors reicht eben nicht. Der zeigt nur etwas an, wenn man auch etwas (seriell) ausgibt. Dazu muß man halt erst mal die serielle Kommunikation initialisieren was normalerweise mit Serial.begin(<Baudrate>) (bitte nicht steinigen wenn ich den Befehl nicht korrekt geschrieben habe) erfolgt, damit überhaupt eine serielle Kommunikation statt finden kann. Und dann muß man mit den passenden Befehlen auch was an die serielle Schnittstelle schicken, ansonsten bleibt es beim Serial Monitor bei dem schwarzen Adler auf schwarzen Grund.
wenn er die letzte gültige (und immer noch zum Download angebotene)
1.8.19 installiert.
Na da bist Du nicht auf dem neuesten Stand. Es gibt seit gut 4 Monaten die Version 2.3.10. Unabhängig davon kann man natürlich auch noch die 1.8.19 downloaden.
Es gibt auch viele Entwickler die auf die klassische Methode setzen,
ihren Lieblingseditor benutzen und den Buildprozess dann im Terminal mit
den passenden Tools durchführen.
Mit vim oder Emacs kann man den Buildprozess direkt aus dem Editor aufrufen. Bei vim z.B. mit
Na da bist Du nicht auf dem neuesten Stand. Es gibt seit gut 4 Monaten
die Version 2.3.10. Unabhängig davon kann man natürlich auch noch die
1.8.19 downloaden.
Vielleicht hätte ich in meinem Text noch etwas detaillierter herausarbeiten müssen, dass es hier um die letzte 1.x-er, 1.8-er, 1.8.19-er Version geht. Jedenfalls nicht um die Neueste 2.sonst_etwas. Mein Fehler.
Wenn es bei Arduino bleiben soll, dann spricht nichts dagegen die
Arduino IDE zu installieren.
Es ging in diesem speziellen Fall nicht um Arduino, sondern um die Möglichkeit einfache Algorithmen ohne Hardware-Bezug direkt auf dem PC zu testen. Und um C zu erlernen. Hauptsächlich sogar genau darum.
Vielleicht hätte ich in meinem Text noch etwas detaillierter
herausarbeiten müssen, dass es hier um die letzte 1.x-er, 1.8-er,
1.8.19-er Version geht. Jedenfalls nicht um die Neueste 2.sonst_etwas.
Ist eigentlich völlig wurscht welche Version, die Unterschiede sind nicht so gravierend.
Es ging in diesem speziellen Fall nicht um Arduino, sondern um die
Möglichkeit einfache Algorithmen ohne Hardware-Bezug direkt auf dem PC
zu testen. Und um C zu erlernen. Hauptsächlich sogar genau darum.
Nöö, der Moritz war der Meinung das man das auf dem PC und nicht auf dem µC macht und hat dafür den QT Creator vorgeschlagen.
Wenn ich nicht völlig daneben liege, dann geht es dem TO um eine Lösung für sein Potiproblem (Beitrag "Ich möchte aus einer Spannung einen binärcode erzeugen"). Er hat sich nunmehr entschlossen das mit einem Arduino umzusetzen. Mit Programmierung hat er nicht arg viel am Hut, aber er muß es jetzt zwangsläufig tun, damit der Arduino das macht was er will. Mit irgendwelchen Testgeschichten auf dem PC wäre er vermutlich hoffnungslos überfordert, insofern hilft der Vorschlag vom Moritz dem TO nicht wirklich. Und natürlich kann man C auch durch das Programmieren eines µC erlernen, weil es völlig egal ist ob man die "einfachen Algorithmen" von einem µC oder einem PC durchrechnen läßt.
Ich habe mit C angefangen, weil ich einen µC programmieren wollte. Erst danach habe ich ein paar kleinere Progrämmchen für den Raspi geschrieben.
Und natürlich kann man C auch durch das Programmieren eines µC
erlernen, weil es völlig egal ist ob man die "einfachen Algorithmen" von
einem µC oder einem PC durchrechnen läßt.
Bei den Algorithmen, die im anderen Thread von Norbert gezeigt wurden, wäre es IMO aber doch praktisch, sie mal auf einem Rechner mit Stdin und -Out zu testen.
Das spielt doch keine Rolle, ob das Kind stdout, Serial.print oder cout
heißt.
gdb anyone? Single step, Variablen anschauen, modifizieren, restart, usw.
Gerade für Anfänger eine Erleuchtung und auch Hilfe beim Verstehen von unbekannten Algorithmen.
Hier mal grafisch mit geany und per bash command line. Also einmal mit klicken, einmal mit tippen.
Single step, Variablen anschauen, modifizieren, restart, usw.
Gerade für Anfänger eine Erleuchtung und auch Hilfe beim Verstehen von
unbekannten Algorithmen.
Nun das geht mit der passenden IDE und einer Debugging Schnittstelle (JTAG) auch mit einem µC.
Ich habe das selbst schon mit einem MSP430xx von TI und der CCS IDE (Code Composer Studio - einer auf Eclipse basierenden IDE von TI) gemacht.
Beim Arduino (Nano) ist es schwierig, weil dieser keine passende Hardwaredebugging Schnittstelle hat. Dennoch soll es mit VS Code und Platform IO Erweiterung funktionieren. Wie es genau geht ist im Netz beschrieben. Ehrlicherweise muß ich sagen, daß ich es selbst noch nicht ausprobiert habe.
Bei den beliebten ESP32 gibt es Modelle mit integriertem USB/JTAG, wo das Debugging mit VS Code/Platform IO oder auch mit der neuen Arduino IDE funktioniert.
Langer Rede kurzer Sinn, es hängt schlichtweg von der verbauten HW ob man direkt debuggen kann oder nicht. Es macht schon durchaus Sinn manche Dinge auf der Zielhardware (µC) zu machen, insbesondere dann, wenn man mit seiner Software die HW des µC anspricht.
Langer Rede kurzer Sinn, es hängt schlichtweg von der verbauten HW ob
man direkt debuggen kann oder nicht.
Die neueren ATtiny bieten ja UPDI.
Es macht schon durchaus Sinn manche
Dinge auf der Zielhardware (µC) zu machen, insbesondere dann, wenn man
mit seiner Software die HW des µC anspricht.
Andererseits sind AVRs so einfach aufgebaut, daß Versuch-Irrtum binnen weniger Sekunden ausprobiert werden kann.
Wenn man volle Kontrolle bei 8-Bittern haben möchte, bietet sich Assembler an ;-)
Mit dem Minicore kann die Arduino IDE den ATmega328 debuggen. Als Debugger und Programmieradapter bietet sich ein zweiter Arduino Nano mit der dw-link Firmware an.
Allerdings behindert ein Kondensator am Reset Pin des Arduino Nano Boardes die DebugWire Kommunikation. Der muss runter, was sich wiederum auf die Aktivierung des Bootloaders auswirkt. Lange Rede, kurzer Sinn: suboptimal für Anfänger.
Mit neueren Boards die eine CPU mit ARM Cortex-M Kern haben, haben es die Anfänger leichter, denn bei denen funktiert das Debugging in der Arduino IDE out of the Box.
So sehr ich die 8 Bit AVR mag, ich schätze, dass sie in 5 Jahren von der Bildfläche der Hobbybastler verschwunden sein werden.
Nun das geht mit der passenden IDE und einer Debugging Schnittstelle
(JTAG) auch mit einem µC.
Wir reden hier von Arduino und der IDE
Und es geht darum völlig µC-unabhängigen Code in einem einfachen, Anfänger-tauglichen Umfeld zu testen. So langsam wird es mühsam, wenn man jedes Mal den kompletten Thread-Verlauf erklären muss.
ie mal auf einem Rechner mit Stdin und -Out zu testen.
Das spielt doch keine Rolle, ob das Kind stdout, Serial.print oder cout
heißt. Und dem Arduino tut das auch nicht weh!
Ja äh also... da braucht man erstmal eine Baudrate, die dann auch noch auf beiden Seiten gleich sein muß, dann muß man damit Serial.begin() aufrufen und ein Terminalprogramm oder den Serial Monitor der Arduino-IDE damit konfigurieren, und Formate kann Serial.print() meines Wissens auch nicht, im
Gegensatz zu (std::)printf() aus den stdio.h oder cstdio Headern.
Vielleicht sind Deine Anfängerzeiten ja schon eine Weile her, aber für Anfänger sind das alles Hürden, die bei einem simplen printf() nicht überwunden werden müssen. In dem anderen Thread hatte jemand Probleme mit Arduinos Serial-Library, weil er die Sache mit der Groß- und Kleinschreibung nicht beachtet hat.
Irgendwie habe ich bei Deinen Ausführungen häufig das Gefühl, daß Du vergessen hast, was ein Anfänger ist und wie man Anfängern etwas beibringen kann. Das ist schade, denn mit Deiner Erfahrung könntest Du das sicher gut, wenn Du diesen Aspekt beachten könntest.
Ja äh also... da braucht man erstmal eine Baudrate, die dann auch noch
auf beiden Seiten gleich sein muß, dann muß man damit Serial.begin()
aufrufen und ein Terminalprogramm oder den Serial Monitor der
Arduino-IDE damit konfigurieren, und Formate kann Serial.print() meines
Wissens auch nicht, im
Gegensatz zu (std::)printf() aus den stdio.h oder cstdio Headern.
Vielleicht sind Deine Anfängerzeiten ja schon eine Weile her, aber für
Anfänger sind das alles Hürden,
Diese Hürde sehe ich nicht. Serial.print() ist einfach zu schreiben und man findet direkt Beispiele. Zumindest ich hatte damit keinerlei Probleme, die sehe ich eher bei den Funktionen mit Formatierung. Die Handhabung der Arduiono-IDE zwecks serieller Anzeige ist ja wohl äußerst simpel.
Ihr solltet differenzieren, ob man zwecks Debugging ein paar Werte sehen will oder dauerhaft chice Ausgaben zum Bildschirm braucht.
Und es geht darum völlig µC-unabhängigen Code in einem einfachen,
Anfänger-tauglichen Umfeld zu testen.
Du meinst der TO hätte ein Interesse daran? Nein hat er nicht, der möchte den Nano für seine Zwecke zum Laufen bekommen. An tiefer Gehendem hat er kein Interesse.
Zudem warum sollte ich völlig µC unabhängigen Code testen wollen, wenn das Ziel meiner Bemühungen eine Programmiersprache zu erlernen am Ende das Programmieren eines µC ist? Diese Logik erschließt sich mir nicht wirklich. Da teste ich doch lieber mit dem Ziel meiner Begierde.
Ja äh also... da braucht man erstmal eine Baudrate, die dann auch noch
auf beiden Seiten gleich sein muß, dann muß man damit Serial.begin()
aufrufen
Das ist natürlich die absolute Schwierigkeit. Schau Dir einfach mal die Beispielprogramme der Arduino IDE an, da ist das meist das Erste was gemacht wird. Auch logisch, weil Ausgaben auf dem Arduino ohne zusätzliche HW, die natürlich auch angesteuert werden muß, schlecht möglich sind. Da bleibt zur Ausgabe nur die serielle Kommunikation. Allerdings ist eh über die IDE vorhanden, weil darüber auch die Programmierung läuft.
n dem anderen Thread hatte jemand Probleme mit Arduinos Serial-Library,
weil er die Sache mit der Groß- und Kleinschreibung nicht beachtet hat.
Das hat aber nichts mit der Arduino Serial-Library zu tun. Das ist schlichtweg dem zu Grunde liegenden C++ geschuldet, welches bekanntermaßen case-sensitive ist. Arduino F. hatte das aber schon in einem Post angemerkt.
und Formate kann Serial.print() meines Wissens auch nicht, im
Gegensatz zu (std::)printf() aus den stdio.h oder cstdio Headern.
Dafür gibt es bei Arduino sprintf(),
Pufferüberlauf, ick hör Dir trappsen. Meinst Du nicht, daß snprintf() die bessere Wahl ist?
Davon abgesehen muß man beide Funktionen natürlich erstmal kennen. Ich erkenne da einen Fehler der Kategorie Beginner Underrun.
Klar, man kann sich ja immer eine Funktion aus dem feinen Manuel picken und dann sagen, daß es doch ganz einfach ist. Steht ja im Manuel, ne, und warum sollte so ein Anfänger das nicht erstmal auswendig lernen. Haben wir doch in den Achtzigern auch gemacht. Der soll erstmal schwitzen, das faule Schwein, und leiden und sich das Privileg verdienen, programmieren zu dürfen!
Ja äh also... da braucht man erstmal eine Baudrate, die dann auch noch
auf beiden Seiten gleich sein muß, dann muß man damit Serial.begin()
aufrufen
Das ist natürlich die absolute Schwierigkeit.
Nö, aber hat das denn jemand behauptet? Nein, niemand. Du "widerlegst" hier also etwas, das Du Dir selbst ausgedacht hast. Wow, gut gemacht, einen Tusch für die Glanzleistung, Applaus, Applaus!
Trotzdem ist es aber zunächst einmal eine Hürde, und damit nicht, wie Dr. Superhirn oben behauptet hatte, genau so einfach wie printf(). Es ist nicht so einfach, weil je ein Setup auf dem Arduino und eins bei dem Endpunkt auf der anderen Seite gemacht werden muß. Und auch, wenn das einem erfahrenen User wie Dir, mir, Dr. Superhirn und Norbert als bezwingbare Hürde erscheint: es ist eine Hürde, und für einen Anfänger ist ihre Höhe größer als Null.
