Beiträge von KaiR

    @Pius


    Ja der Code wurde ausprobiert. U.a. in Beitrag #35. Dort wurde auch die Verwendung von strlen() reduziert.


    Ich habe es auch mal auf einem "echten" Nano kaufen lassen. Was mir bei der Arduino Umgebung aufgefallen ist, ist der Umstand, dass die Nutzung von den Typen "byte" oder "uint8_t" mehr Speicherplatz verbraucht als "int". Warum auch immer.

    Aufgefallen ist mir das bei der Speicherung der Stringlänge. Da hatte ich zuerst auch erst uint8_t verwendet. Das hat zwei Byte 8| mehr verbraucht als die Verwendung von "int".


    Dein optimierter Ausdruck ist schwerlich noch weiter zu kürzen:thumbup:. Für Beginner verständlich, ist er allerdings nicht. Jedenfalls für die meisten. Für im Leben auf das Dezimalsystem konditionierte, ist die Bitschieberei erst einmal etwas unübersichtlich. Geht mir auch so.

    Es ist recht einfach. Um den Wert 1 darzustellen muss ein Bit auf die erste Position (von rechts) einer Variablen geschoben werden, für 16 auf die Position 5, 256 auf die Position 9 usw.. Es wird wieder bei 0 angefangen (y=0 als Laufvariable immer um 1 inkrementiert) zu zählen:

    wert = ( 1 << 0 ) // Entspricht 160 0=y*4 1 20

    wert = ( 1 << 4 ) // Entspricht 161 4=y*4 16 24

    wert = ( 1 << 8 ) // Entspricht 162 8=y*4 256 28

    wert = ( 1 << 12 ) // Entspricht 163 12=y*4 4096 212

    usw.


    Im Programmcode ist es nur anders herum 9*4, 8*4...3*4, 2*4, 1*4, 0*4. Es erfolgt also auch eine Potenzrechnung.

    Ein Bitshift von 36 Bits (9*4) entspricht z.B. pow(16,9), 32 Bits = pow(16,8) usw..

    Mi Ke:


    Ich habe das Programm jetzt bei mir auch mal auf den Ardiuno Nano gepackt weil mich interessiert wie das da mit 64Bit Variablen so läuft. Ich muss feststellen, dass die "pow()" Funktion bei mir nur Grütze liefert.


    Die Kombination aus float und uint64_t kommt da offenbar nicht gut an.


    Darum habe ich die Berechnung durch ein Bit-Shift ersetzt. So wird nur noch mit Integer-Variablen gearbeitet. Das wiederum, funktioniert bei mir und zeigt auch bei sehr großen Zahlen das richtige Ergebnis an:



    Durch den Verzicht auf die pow() Funktion ist das Programm auch gute 2kb kleiner (2178Byte statt 4406Byte).

    Ich habe eine Lösung gefunden. Habe jetzt selber wieder etwas dazugelernt :).

    Zumindest funktioniert es laut dem Simulatorprogramm mit dem ESP32.



    Das dürfte ordentlich Speicherplatz kosten. Aber im Prinzip funktioniert es.


    Diese Simulationsseite kannte ich noch nicht... die ist prima.

    Zitat

    Ich nehme mal an ich muss das noch etwas ändern
    for(int i=strlen(input)-1, int y=0; i > -1; --i, ++y){


    Nein. Du musst nichts ändern. Das zweite int vor dem y wird einen Fehler produzieren. Du kannst beim Arduino Framework in der For-Schleife mehrere Variablen definieren aber nur von einem Datentyp. Darum reicht ein int am Anfang.


    Ich kann es nicht mit Sicherheit sagen, aber auch bei Micropython bleibt ein 8-Bit Mikrocontroller ein 8 Bit Mikrokontroller. Darum bezweifle ich, dass dort 64Bit für eine Zahl zur Verfügung stehen.

    Irgendwie muss das Posting #8 und #9 komplett übersehen worden sein.


    Dein Reversieren kanns Du etwas vereinfachen:

    Hier brauchst Du kein Array Offset.


    Die Zahl in Dezimal umzurechnen ist gar nicht so trivial, weil die Zahl zu groß ist um sie in eine 32 Bit Integervariable unterzubringen.

    Aber vielleicht ist das ja auch gar nicht nötig wenn du nur mit den Hexwerten arbeitest.


    Warum brauchst Du die Dezimalwerte?


    Es geht doch wahrscheinlich nur darum einen eingelesenen Wert eines Chips mit einem gespeicherten Wert zu vergleichen um zu erkennen ob der Chip zulässig ist.

    Ja die Enablepins. Die bringen viel. Ich hab mal eine Schaltung gebaut, bei der ich nur den "halben" L293D benutzt habe. Dort hatte ich auch einen ziemlich hohen Ruhestrom bis ich den Enable-Pin des nicht genutzen Teils auf GND geschaltet habe. Das hat auch den Verbrauch im Betrieb reduziert.


    Letztendlich kam dieses bei rum:


    L293D.png


    VCC1 wurde über den Mosfet abgeschaltet wenn der L293D nicht gebraucht wurde. Dadurch ging der Ruhestrom gegen 0.

    Sehr schön :). Ich freue mich auf die weitere Entwicklung dieses Projektes.


    Die 20mA Ruhestromverbrauch wundern mich etwas aber das ist aber wohl dem doppelten Aufbau geschuldet. Wie tief hast Du die LDRs in den Röhrchen versenkt? Sind die ganz unten angebracht oder irgendwo mitten drin?


    Mein Sonnenfolger werkelt übrigens immer noch vor sich ihn...

    @Pius: Ich wollte es fast genau so schreiben. '\0' ist ein Stringliteral für 0. Letztendlich kommt beides auf dasselbe heraus.


    char str[] = {'H','e','l','l','o','\0'};


    Bei den Anführungszeichen habe ich mich vertan.

    Was noch wichtig ist zu erwähnen:


    strncpy kopiert zwar Stringteile, fügt aber keine abschließende 0 ein, die für eine Stringterminierung notwendig ist.

    Dieses Beispiel beweist es: https://www.onlinegdb.com/M1kqI5s8_

    Wenn das so wäre, würde nicht „Marburg“ sondern „Mar“ ausgegeben.


    Unten gezeigtes strncpy Beispiel funktioniert, weil die Char Arrays vom Compiler mit 0 initialisiert werden.

    Sollten in einer Variable nacheinander Stringabschnitte unterschiedlicher Länge kopiert werden, muss zusätzlich noch eine 0 als Stringabschluss gesetzt werden.


    Wie das geht, ist unter dem geposteten Link im Beitrag #6 nachzulesen.

    Bei dem Setzen des Index für das Array ist immer daran zu denken, dass bei 0 angefangen wird zu zählen.

    Wird ein Zeichen zu viel kopiert und die vorhandene „Terminierungsnull“ wird überschrieben, kommt es auch zu seltsamen Phänomenen bis hin zum Totalabsturz.


    Es ist natürlich auch möglich einen String mit "memset" immer wieder mit Nullen zu füllen. Das dürfte aber länger dauern, als wenn nur ein stadt[7]= "\0" verwendet wird.

    Es geht auch so:


    Code
    1. char input[] = "231374139323533413333343833303130303";
    2. char laenderCode[9];
    3. char nId[19];
    4. int offset[2] = { 0, 21 };
    5. strncpy (nId, input + offset[0], 21);
    6. strncpy (laenderCode, input + offset[1], 6);

    Zumindest wenn die Offsets ab dem Stringteile kopiert werden sollen fest und bekannt sind. In diesem Beispiel habe ich die Offsets in einem int Array gespeichert. Der erste Teil wird vom Zeichen 0 bis 20 (=21 Zeichen) kopiert, der zweite Teil ab dem 21. Zeichen mit 6 Zeichen.


    Kannst auch am Onlinecompiler das Beispiel anschauen: Beispiel


    Nicht verwirren lassen. Das ist "richtiges" C. Dort gibt es ein paar Befehle die es in der Arduino Umgebung nicht gibt (wie printf). Aber es geht ja um das Prinzip des Sting zerpflückens. Dort kannst Du auf die Schnelle probieren (auf Fork klicken).


    Eine Seite die noch mehr Stringoperationen beschreibt ist diese hier: https://arduino-projekte.webnode.at/c-funktionen/

    Ich habe gesucht und gefunden. Ich habe noch ein langes RG58 Kabel ausgegraben. Weil keine Stecker mehr am Kabel vorhanden waren, habe ich einen Adapter drangetüdelt. Das andere Ende blieb "offen".


    IMG_1928.JPG


    Dann habe ich mit 1MHz Rechteck und 500 mV VS gemessen und es kam folgendes raus:


    RG58-Reflektion.PNG


    Das passt jetzt zu den Erklärungen :).


    Für die Längenmessung noch etwas reingezoomt:


    RG58-Laengenmessung.PNG


    Abschließend mal gerechnet und es kamen (204ns / 2 / 3,3) * Verkürzungsfaktor 0,66 = 20,4m heraus. Gemessen habe ich unter einigen Verrenkungen und yogamäßig mit dem Zollstock 20,2m... passt also. Nicht hochpräzise aber tauglich ;).


    Mein Messkabel aus dem ersten Versuch war wahrscheinlich einfach zu kurz (Wellenlänge >> Kabellänge) für stärker ausgeprägte Reflexionen, auch wenn der Effekt schon zu erkennen ist.

    Folgende Fehlermöglichkeit gibt es üblicherweise:


    - Kabel defekt -> Prüfen/ austauschen/ anderes probieren.

    - Com-Port in Arduinoumgebung und Gerätemanager sind nicht identisch. Das hast Du ja schon geprüft.

    ArduinoNano2.png


    - Es ist unter Werkzeuge (Bild) nicht das richtige Board eingetragen

    - Es ist evtl. der falsche Bootloader ausgewählt, falls es mehrere gibt.

    - Auf dem Board ist gar kein Bootloader drauf. -> Anderes Board probieren.

    - Die digtalen Pins 0 (Receive RX) und 1 (Transmit TX) sind in der Schaltung verwendet und angeschlossen. -> Abklemmen, Programm hochladen, wieder anklemmen.


    Wenn alles nicht hilft evtl. den C340 Treiber neu installieren. Obwohl das unter Win10 eigentlich nicht notwendig sein dürfte.


    Mehr fällt mir im Moment nicht ein.


    Es ist bei deinen Screenshots nicht erkennbar was Du für ein Board benutzt. Welches ist es?

    Aehm ... das Bild wo du 50ns siehst, ist das Bild aus dem von Dir geposteten Video. Das habe ich hochgeladen um zu erklären was ich mit "Siegertreppchenform" meine.


    Daraufhin habe ich mich auch meinen Screenshot ohne Endwiderstand im Posting #229 bezogen. Dort ist eine Skaleneiteilung von 20ns eingestellt und man sieht nichts von einer Signallaufzeit von 10ns bevor sich die Energie aufaddiert, so wie es ja eigentlich erklärt wurde. Man sieht nur eine stetig steigende Flanke die 10ns braucht um die Amplitude zu erreichen.


    Was ich damit sagen will, meine Messungen scheinen nicht so ganz zu den Erklärungen zu passen.