Variablen an Funktionen übergeben scheitert!?

DirkB

@j-foe PHP und C sind verschiedene Generationen von Programmiersprachen.
C ist von Profis für Profis gemacht worden, die wissen was sie tun.

Der Arduino war ursprünglich ein 8-Bit Mikrocontroller. Gerade die von dir gelobten assozoativen Arrays brauchen viel dynamischen Speicher, den das kleine Teil nun mal nicht hat.

Aber der Arduino verstent durchaus C++ und hat eine eigene Klasse für Strings.

Und wenn du einen 32-Bit-Controller hast, spricht auch nichts gegen den Einsatz von C++ (auch ohne Arduino-Umgebung.)

Quiche Lorraine

@j-foe sagte in Variablen an Funktionen übergeben scheitert!?:

Das kann ich mir in C nicht ansatzweise vorstellen, dass das irgendwie geht. Aber C soll das wahrscheinlich auch überhaupt nicht leisten, sondern hardwarenah sein, was man beim Umstieg doch enorm merkt.

C hat halt wenig syntaktischen Zucker und viele Dinge müssen von Hand gemacht werden. Es erfordert eine Menge Diszplin um in C sauber zu programmieren.

BTW: Vor einiger Zeit wollte ein Kollege man eine1E6 x 1E6 Matrix in Dreiecksform in C invertieren. Ich habe ihm die GSL Lib empfohlen. Nur mal damit du eine Vorstellung von wissentschaftlicher Arbeit unter C bekommst. :->

BTW: Ich mag kein C++ auf kleinen Embedded Controller, weil man nicht weiß wieviel C++ da funktioniert. 2 KB SRAM auf einem ATmega328 ist halt nicht viel.

j.foe

Ja, sag ich ja, die Sprachen sind in allem wirklich sehr unterschiedlich. Das merke ich deutlich.

Die Tastatur bekomme ich nun auch in den Griff.
Ich hatte bei der Lib etwas ins Klo gegriffen und mich von der Bescheidenheit dessen ablenken lassen, der die bessere Lib geschrieben hat.

Quiche Lorraine

@DirkB sagte in Variablen an Funktionen übergeben scheitert!?:

C ist von Profis für Profis gemacht worden, die wissen was sie tun.

Sorry, aber bei mir sträuben sich da die Nackenhaare. Denn egal welche Programmiersprache benutzt wird, es gibt immer wieder weniger qualifizierte Nutzer und dann kommen Stilblüten der folgenden Form zu Tage:

#include "sdk_common.h"						// Besteht aus mehreren tausend #define Anweisungen, welche pro Projekt konfiguriert werden müssen.
#if NRF_MODULE_ENABLED(APP_FIFO)			// ???
#include "app_fifo.h"

#define FIFO_LENGTH() fifo_length(p_fifo)  	// Makros werden sehr oft benutzt

DFU_TRANSPORT_REGISTER(nrf_dfu_transport_t const ble_dfu_transport) =
{
    .init_func  = ble_dfu_transport_init,
    .close_func = ble_dfu_transport_close,
};

NRF_BALLOC_DEF(m_buffer_pool, MAX_DFU_PKT_LEN, MAX_DFU_BUFFERS);	// malloc? 

__WEAK void assert_nrf_callback(uint16_t line_num, const uint8_t * file_name)  // _WEAK muss man auch erst mal kennen
{
}

NRF_FSTORAGE_DEF(nrf_fstorage_t fstorage) =		// Scheint eine Art von IPC Variable zu sein, welche recht anfällig für falsch konfigurierte #defines ist
{
    .evt_handler = fstorage_evt_handler,
    .start_addr = 0x3e000,
    .end_addr   = 0x3ffff,
};

#endif

Und das ist nur ein best off 5 minutes.

Und da wünsche ich mir halt mehr syntaktischen Zucker in C. Vor allen Dingen wenn man Elemente aus höheren Programmiersprachen benötigt. Denn ehrlich gesagt möchte ich keine C Laien Implementierung mehr von std::vector oder std::list sehen, kein goto CleanUpRessources, keine mangelnde Typsicherheit,...

SeppJ

Beschuldige nicht den Erfinder des Hammers für die Taten von Sonntagshandwerkern.

"von Profis für Profis" ist schon historisch richtig, aber der erste Compiler musste ja auch auf einem 1970er Computer laufen (wo so etwas wie "der kann ASCII" bahnbrechend war). Da kannst du die Sprache nicht mit tonnenweise Syntaxzucker vollladen. Gewissermaßen war C zu der Zeit tonnenweise Syntaxzucker auf Assembler.

j.foe

Man hätte für die Arduinos was anderes finden sollen. Es gibt zwar Python auch nun dafür, aber ich mag die Sprache nicht.
Naja, muss man irgendwie durch, wenn man die Teile nutzbar machen will.

Anfangs ging nun auch die neue Lib für PS2 gut, aber jetzt erkennt der kein SHIFT und Großbuchstaben sind damit tabu... achje... wie kann das denn passieren!?
Bei der anderen Lib gehen die Funktionstasten nicht, auch wenn man die Lib mit Werten bestückt, was schon auch kurrios ist...

Hat jemand Erfahrungen mit einer Lib für PS2 Tastaturen?

omggg

Was war eigentlich noch mal die Frage gewesen? Wie man eine (utf8) Zeichenkette in PHP und C splittet?

Schlangenmensch

@j-foe Naja, Arduino kommt halt aus der Microcontroller Welt. Da ist/war c erstmal das Mittel der Wahl, da für Abstraktionen häufig die Ressourcen fehlen. Arduino hat einen C++ Compiler, und wenn man C++ kann, bekommt man einiges an Abstraktionen, wewlche zur Compiletime soweit zerfallen, dass man es in der Anwendung nicht mehr merkt.

Die einfache Variante wäre, die String Klasse aus der Arduino Biblitothek für Strings zu verwenden. Jetzt allokiert die Speicher auf dem Heap. Speicher auf dem Heap hat man in der Microcontroller Welt nur begrenzt zur Verfügung, im Gegensatz z.B. zu PC Anwendungen. Daher ist man damit eher zurück haltent.

Vlt gibt es irgendwo auf Gihub auch Code, der C-Artige Zeichenketten als Klasse kapselt, so das man von außen das einfach benutzen kann. Würde sich vlt mal lohnen nach zu suchen.

Aber, dein eigentliches Problem war die Verwirrung zwischen Zeichenkette char* die man mit "" umschließt und einzelnen Zeichen char die man mit ''umschließt, richtig?

Wenn du lieber mehr highlevel Programmiersprachen mit mehr Abstraktionsmöglichkeiten verwenden willst, ist vlt der Arduino nicht das richtige Mittel und du könntest drüber nachdenken, auf nen Raspi umzusteigen.

j.foe

@omggg In PHP Kinderkram ... in C++ eine fiese Aufgabe.

j.foe

@Schlangenmensch Ja, genau, die Zuweisung war das Hauptproblem, da diese in anderen Programmiersprachen so nicht unterschieden werden (trotz dem sie sich aber zum unterscheiden eignen und so genutzt werden, aber nur um sich gegeneinander abzugrenzen.).
Das hilft mir hier schonmal weiter.
Momentan aber habe ich das nächste Problem vor mir... urgs! Die Lib für die Tastatur scheint nicht ok zu sein, aber fixen kann ich das natürllich nicht... ich habs versucht, aber kam noch mehr Quark raus... klaro!
Ich mache da vllt. mal einen neuen Fred auf dazu. Vielleicht kann da ja jemand helfen? Das wäre spitze!

wob

@j-foe sagte in Variablen an Funktionen übergeben scheitert!?:

In PHP Kinderkram ... in C++ eine fiese Aufgabe

Nein, in "normalem Computer-C++" auch Kinderkram.

Du hast z.B. auch oben von "assoc arrays" geschrieben. Die gibt es in C++ natürlich auch, das nennt sich allerdings std::map bzw. std::unordered_map (siehe https://en.cppreference.com/w/cpp/container/map). Und für Strings würdest du normalerweise std::string nutzen (und nicht char *). Diese Klassen sind Teil der Standardbibliothek. Auf einem normalen PC ist die Bibliothek natürlich verfügbar und es wäre überhaupt kein Problem, sowas in C++ zu schreiben.

Das Problem ist nun, dass du auf dem Arduino die Bibliothek nicht zur Verfügung hast. Stell es dir vor wie php, wo die normalerweise verfügbaren Funktionen einfach fehlen. Siehe auch https://stackoverflow.com/questions/37575303/is-the-c-standard-library-fully-supported-on-arduino - es ist also nicht so sehr ein C++-Problem, sondern eher dem Arduino geschuldet.

j.foe

@wob Ja, die std::map hatte ich auch schon im Auge, aber das sah mir immer nur aus wie eine Tabelle, nicht wie ein multidimensionales Array. Da hatte ich das dann gelassen und Arrays brauchen viel Speicher, das hatte ich zu Beginn auch dann gleich gemerkt.

Jo, am Arduino ist einiges nicht verfügbar. Aber wahrscheinlich eben, wegen des kleinen Variablenspeichers.
ESP32 ist glaub etwas großzügiger, aber da läuft nicht alles, was ich brauche, leider. Da habe ich Probleme, den Output für den KC auf einem Pin zu generieren, aber ich hatte das auch noch nicht arg ausgetestet... es lief zumindest nicht auf Anhieb. Die Pins für entsprechenden Output sind auch andere, da muss ich mal schauen. Derzeit reicht der Arduino aber noch.

Wird schon werden, ist ja nur Hobby...

SeppJ

Du redest wirres Zeug. Ein assoziatives Array ist ja gerade kein multidimensionales Array, sondern so etwas wie eine Tabelle. Eben wie std::map. Und "normale" Arrays sind die speichersparendste Form, Information zu speichern. Daher ist das ja auch bevorzugt für den Mikrocontroller, anstatt dort den Speicher für den Aufbau von Assoziationen zu verschwenden, die man gar nicht braucht.

Das soll kein Angriff sein, aber du musst wirklich zwei Sachen lernen:

Wie diverse Standarddatenstrukturen wirklich im inneren auf der Hardware funktionieren
Dir fehlt tatsächlich ein bisschen das logische Verständnis, z.B. wie schon oben beschrieben, dass eine Tüte Gummibärchen was anderes ist als die Gummibärchen darin

Du bist ein bisschen zu verwöhnt von vermeintlichen Anfängersprachen, die dir die Notwendigkeit um dieses Wissen abgenommen haben (auf Kosten von Effizienz). Aber bei einem Mikrokontroller ist Effizienz alles, und du musst diese Konzepte verstehen.

Finnegan

@j-foe Ein paar Ideen:

Das char*-Ausgabe-Beispiel hier konfiguriert zuerst eine Übertragungsrate mit Serial.begin(...). Der Aufruf dieser Funktion und das Setzen einer für das Board unterstützten Baudrate ist möglicherweise obligatorisch.
Die Arduino-API hat auch eine eigene String-Klasse. Ich kenne zwar die Details nicht, aber ich denke die ist im Gegensatz zu std::string sehr leichtgewichtig und an die Anforderungen auch der kleinen Boards angepasst.
Ansonsten halte ich C++ auch für eine gute Sprache für Microcontroller, da damit viel elegantere Abstraktionen möglich sind, als mit C. Ich denke da z.B. an Destruktoren, RAII und Templates, die auch auf Systemen mit nur 1 KiB RAM hilfreich sind und nicht mehr Overhead haben müssen, als das C-Äquivalent.

Man muss sich nur eben auf bestimmte Funktionalität beschränken, die für so kleine Computer geeignet sind. Statt einer relativ "schweren" std::map würde ich vielleicht schauen, was es für Arduino-Bibliotheken gibt, wie z.B. Hashtable und Unorderedmap.

Bei Klassen wie std::array oder std::string_view hingegen hätte ich wenig Bedenken, die auch auf dem Arduino einzusetzen, sofern die da überhaupt verfügbar sind. Die haben keinen bis minimalen Overhead (std::array ist wie ein C-Array und std::string_view hat maximal einen zusätzlichen end-Pointer). Mit std::string_view könnte man sogar den ganzen char*-Strings ein intuitiveres Interface verpassen ohne dynamischen Speicher verwenden zu müssen - aber wie gesagt, ich weiss nicht, wie leicht sich Teile der C++-Standardbibliothek mit der IDE und dem Compiler nutzen lassen.

j.foe

Ah, das mit der speziellen String Klasse für Arduinos klingt interessant! Danke für den Wink!

Ja, für vieles ist C++ schon ok, aber oft eben auch an Stellen nervig, die in der Form eher verwirren... vllt. daher die neue Klasse auch?
Die schaue ich mir mal an!

*john 0

@SeppJ sagte in Variablen an Funktionen übergeben scheitert!?:

Du redest wirres Zeug. Ein assoziatives Array ist ja gerade kein multidimensionales Array,

Er redet über PHP, und da gibt es das tatsächlich. C++ kennt das nicht, aber warum sollte M["Hello","World"] = "Hurz"; nicht funktionieren? Mit runden Klammern kann man das schon seit Jahren umsetzen, und mit den eckigen in der neuen Norm.

Finnegan

@j-foe sagte in Variablen an Funktionen übergeben scheitert!?:

Ah, das mit der speziellen String Klasse für Arduinos klingt interessant! Danke für den Wink!

Ja, für vieles ist C++ schon ok, aber oft eben auch an Stellen nervig, die in der Form eher verwirren... vllt. daher die neue Klasse auch?
Die schaue ich mir mal an!

Da schon die direkte Ausgabe von String-Literalen bei dir Probleme macht mit

Serial.print(" befehlszeile:");

glaube ich nicht, dass die kaputten Zeichen das am String-Datentyp liegen.

Da ist irgendwas nicht richtig konfiguriert, und auch wenn ich mich mit den Maschinchen nicht gut auskenne, tippe ich eben auf so etwas wie Serial.begin(speed). Das solltest du als erstes mal ausprobieren, bevor du mit anderen String-Typen hantierst, die dann immer noch Müll ausgeben.

Versuch soch einfach mal dieses Beispiel hier (unten) ans laufen zu bekommen. Das müsste ja eigentlich funktionieren, wenn es in der Arduino-Doku steht.

Und wenn das klappt, dann machen natürlich eventuell String-Klassen Sinn, anstatt nackte char* - sofern du überhaupt dynamische und nicht nur statische Strings benötigst.

DirkB

@Finnegan sagte in Variablen an Funktionen übergeben scheitert!?:

Da schon die direkte Ausgabe von String-Literalen bei dir Probleme macht mit
Serial.print(" befehlszeile:");

Das kommt an. Schau mal genau hin.

Finnegan

@DirkB sagte in Variablen an Funktionen übergeben scheitert!?:

@Finnegan sagte in Variablen an Funktionen übergeben scheitert!?:
Da schon die direkte Ausgabe von String-Literalen bei dir Probleme macht mit
Serial.print(" befehlszeile:");
Das kommt an. Schau mal genau hin.

Ups! Tatsächlich. Zu schnell überflogen. Dann liegts eventuell doch am Pointergefummel