Dieses Thema ist ein schönes Beispiel davon, wie wichtig es ist, erst einmal das Problem zu klären, bevor man anfängt, über Lösungen zu sprechen.
PS: Bitte beim Zitieren den Kopf behalten, damit man leichter den zugehörigen Beitrag findet.
Projektleitung
Anmeldungsdatum: Beiträge: 12801 |
Dieses Thema ist ein schönes Beispiel davon, wie wichtig es ist, erst einmal das Problem zu klären, bevor man anfängt, über Lösungen zu sprechen. PS: Bitte beim Zitieren den Kopf behalten, damit man leichter den zugehörigen Beitrag findet. |
||||
(Themenstarter)
Anmeldungsdatum: Beiträge: Zähle... |
Also der untere und obere Wert wird ganz am Anfang des Scriptes neu erfasst, und ist jedes mal ein wenig anders, aber einmal erfasst bleibt er gleich. Dann bekomme ich laufend, jede 0.1s einen aktuell gemessenen Wert. Den Wert möchte ich prozentual ausrechnen wo der zwischen min und max liegt. Irgendwie rechnet das zwar jeder anders, und ich würde es nochmals anders rechnen (-: aber ich glaube wir meinen alle das selbe. Ich würde "(aktueller Wert - min Wert) * 100 / Differenz von min und max" rechnen, bin mir aber noch nicht ganz sicher ob es wirklich stimmt, sollte eigentlich... Und ja, es gibt das alles mehrfach, darum müsste man (so wie ich das gemacht habe) dann neu mit Array a, und Array b, und Array c für min, max, und aktueller Wert auflisten.
Das Problem ist eigentlich mal vorläufig geklärt, ich probiere mal alles aus, und schaue ob alles funktioniert mit den Arrays. Danke für die Hilfe allen. Die Eingabedatei sieht zB so aus 150 355 90 5 1011 836 200 ... Das mit immer 50 Zeilen, immer die erste Zeile ist der 1. aktuelle Wert. Genauer gesagt, habe ich neu angefangen nicht immer auf alle 50 zu warten, sonder auf die ersten 50, und sie dann wieder zu löschen, damit ich schneller die nächsten 50 schon anfordern kann (die zuerst von einem Arduino ausgelesen werden müssen).
Ja, aber...
Es geht immer der Reihe nach, also es werden die aktuellen Werte vom 1. Arduino angefordert, dann die bekommenen ausgelesen und den Prozent ausgerechnet, und wieder weiter geleitet an den 2. Arduino. Und das halt so schnell wie es geht, also es werden zuvor schon 1x 50 Werte angefordert, und dann wenn sie da sind die nächsten schon wieder angefordert, und während dem die erhaltenen ausgerechnet und weitergeleitet. |
||||
(Themenstarter)
Anmeldungsdatum: Beiträge: 141 |
Also ehrlich gesagt, ich verstehe schon mal nicht den Unterschied zwischen declare -a, und -A. eigentlich wenn ich a[b] machen wollen würde, müsste ich -A nehmen, so wie ich das verstanden habe, weil mit -a wären es Nummern der Reihe nach, in den eckigen Klammern. Aber es funktioniert bei mir auch mit -a, ich kann "declare -a a" machen, und dann "a[b]=100". Ist das normal? Was soll ich den jetzt nehmen wenn ich alles möglichst überall variabel machen will, mit Buchstaben und Zahlen? Edit: Ah nein, irgend etwas funktioniert nicht mit -a, es gibt dann nur noch das zuletzt Gesetzte, alle vorherigen gesetzten Indexe? sind dann gleich. Mit -A kann ich aber auch einen Index mit Zahlen benennen. Also scheint mir -A freier zu sein. |
||||
Projektleitung
Anmeldungsdatum: Beiträge: 12801 |
Es gibt also nicht 50 Intervalle sondern nur eins für alle Messungen?
Ja, das ist ja auch die Formen, die ich gepostet habe.
Ich bin nicht überzeugt, dass Du wirklich Arrays brauchst. Oben klingt es so, als ob Du pro Durchgang nur ein Min und Max hast. Dann benötigst Du vermutlich kein Array, weil Du die Werte ja bearbeiten kannst, wie Du sie liest.
Für mich nicht. Ich hoffe, Du hast es klar.
OK, das ist ja simpel.
Ja, das könnte man z.B. erreichen, indem man die Datei erst öffnet und dann mit
Wie, jetzt also doch 50 Min und Max pro Durchgang?
Das beantwortet meine Frage nicht. |
||||
(Themenstarter)
Anmeldungsdatum: Beiträge: 141 |
Nein, in einem Intervall werden alle 50 Messungen ausgelesen aus der Eingabedatei. (Man könnte erwähnen das sie nicht alle zusammen auf einen Schlag dort auftauchen, aber es wird gewartet bis alle 50 dort sind. Ausser du weisst gerade wie man in einer while read line Schleife, wenn man bei der letzten Zeile angekommen ist, erneut nach der nächsten schaut wenn man noch nicht bei Zeile 50 angelangt ist? Sozusagen ein versuche nochmals zu schauen ob es eine nächste Zeile gibt.)
Aber den aktuellen Wert den ich jedes mal erhalte muss ich nutzen, und ich müsste zB: a1=1 b1=01 while read -r line; do a2=$a2:1"$(eval 'echo $b'$a1)"$line" a1=$(($a1+1)) if [ $a1 -gt 50 ]; then break fi done < Eingabedatei Es gibt nur noch 2 Sachen die noch nicht gemacht sind in diesem Code, wenn $line nicht 3 Stellig ist müssten vorher auch noch nullen hin (ausser du weisst gerade wie man eine Rechnung macht die immer 3 Stellen hat?), und im 1. Durchlauf müsste noch ohne Doppelpunkt $line aufgenommen werden. Aber sonst meinte ich es so wie es da steht, und ich wüsste auch wie ich die 2 Sachen löse. Das Problem ist eben auch das ich an den Arduinos immer eine 6 Stellige Zahl senden muss (mit : getrennt oder nichts am Ende, weil Endzeichen auch gesendet wird). Und in diesem while read line Abschnitt macht der Befehl eval echo alles zunichte, da echo zu viel Zeit verbraucht. Es würde eben funktionieren wenn ich ohne echo $b$a1 ausgeben könnte. Oder mit einem Array, aber ich bin bei genau dieser Ausgabe stecken geblieben, wie gebe ich alles aus dem Array aus ohne Abstand dazwischen und ohne weiteren Befehl der das weg schneidet?? Bei den letzten 2 Fragen verstehe ich dich nicht ganz richtig, was meinst du mit Intervall? Und wieso beantwortet das nicht deine Frage? Es ist genau so wie ich es 1 vorher geschrieben habe:
Edit: Nur diese Zeile ist eigentlich das Problem: "a2=$a2:1"$(eval 'echo $b'$a1)"$line" ". Es ist nur wegen dem echo Befehl der zu lange braucht in jeder Schleife. Ich müsste zu dieser Variable kommen ohne eval echo, evtl nur mit eval wenn das geht, oder eben mit einem Array (ohne Abstand zwischen den einzelnen ausgegebenen Indexen) Edit 2: Ah und $line müsste natürlich auch noch in Prozent umgerechnet werden im Code. Aber es bleibt das Problem wegen dem eval echo Edit 3: Also man könnte das Problem sehen wo man will, wenn ich eine Variable immer 2 Stellig ausgeben könnte, mit 0en vorne wenn sie nicht 2 Stellig ist, und ohne zusätzlichen echo oder print Befehl, dann sieht es für mich im Moment auch so aus als ob das Problem gelöst wäre. Aber ich komme immer wieder an diesen Punkt mit diesem Variablen Problem, deshalb eher wie man $b$a1 ausgibt ohne zusätzlichen Befehl der zu viel Zeit verbraucht. Oder eben vielleicht Array ohne Abstand zwischen den Indexen. |
||||
Anmeldungsdatum: Beiträge: 17548 Wohnort: Berlin |
Hast Du das probiert und gemessen, mit echo und bc, oder ist das eine Vermutung? Wieso werden die Werte erst in eine Datei geleitet? Ich muss auch sagen, dass ich das Problem nicht verstanden haben. Kannst Du es mal mit 5 Werten erklären? Variablennamen in Skripten zusammenzupfuschen ist ein Problem, das so seit Äonen versucht wird, und ich gestehe reumütig, in meiner Spätjugend das auch probiert zu haben.
Die Zeile ist jedenfalls falsch - unbalancierte Anführungsstriche. a2 ist vorher gar nicht initialisiert, b auch nicht - wieso zeigst Du nicht das ganze Script? Ist es über 1000 Zeilen lang? So kann man schlecht raten, was der Code tun soll.
Das kann printf:
Das Formatierungszeichen heißt 0:führende Nullen, 3:3 Stellen, d:Digits. |
||||
(Themenstarter)
Anmeldungsdatum: Beiträge: 141 |
Ja ich habe es mit time gemessen, und auch mit date +%S.%N, allerdings weis ich grad nicht mehr was ich eigentlich gemessen habe, irgendwie geht ein echo oder printf Befehl jetzt auf einmal praktisch ohne Verzögerung. Es liegt irgendwie daran: v1=1 a1=123 while read -r line; do eval 'echo $a'$v1 > /dev/zero done < Eingabedatei das als Script, mit time bash script, misst insgesamt so um die 0.04s auf dem Raspberry Pi 4. Aber das v1=1 a1=123 while read -r line; do a2=$(eval 'echo $a'$v1) done < Eingabedatei misst ca 0.4s ?? Wieso den das?? Wo ist da die Logick?
Weil ich am Anfang (von einem anderen Script) "cat /dev/ttyUSB0 > Eingabedatei &" gemacht habe. Keine andere Möglichkeit hat bei mir funktioniert, es kam nie etwas heraus aus ttyUSB0, nur mit cat funktionierte es.
Ah ja stimmt, es sollte a2=$a2:1"$(eval 'echo $b'$a1)""$line" sein, aber ich bin mir nicht einmal sicher ob alle " nötig wären, ich trenne nur (manchmal) Variablen so ab.
Das Script hat 300 Zeilen und ich hatte es jetzt eigentlich nicht vor gleich das ganze auf zu liste, es ist noch nicht fertig, sieht wahrscheinlich wirr aus für alle die es nicht selbst geschrieben haben, und es funktioniert noch nicht so wie es sollte. Ausserdem hängt es eben auch mit allem anderen zusammen, was auf den Arduinos drauf ist, und mit allen anderen Scripten die vielleicht auf dieses Script zugreiffen.
Ich weiss eigentlich langsam auch nicht mehr an was es liegt, wieso geht eine Variable setzen mit eval echo so lange, aber einfach umleiten nach dev/zero geht so schnell? Mein Bestreben eval echo zu vermeiden beruht darauf das es so lange geht eine Variable damit zu setzen. Wenn ich eval echo weiter benützen könnte hätte es gar kein Problem gegeben... Edit: Ich habe mal eine neue Datei erstellt, vereinfacht mit dem grundlegendsten vom Script. Ich habe es zwar jetzt nicht getestet, also es könnte sein das noch Fehler darin sind und ob sed -i so mit dieser Variable funktioniert weiss ich noch nicht. Aber es sollte eigentlich so in etwa funktionieren, bei der while schleife stecke ich jetzt. a1=01 a2=02 b1=0 b2=0 c1=0 c2=0 d1=2 # max Anzahl an Werten (b und c und aktueller wert) d2=1 echo "anfang" sleep 5 while [ $d2 -le $d1 ]; do echo 3"$(eval 'echo $a'$d2)"000 > /dev/ttyUSB1 eval 'b'$d2=$(sed -n $(($d2))p Eingabedatei | tr -dc '0-9') # es hat ohne tr unsichtbare sonderzeichen d2=$(($d2+1)) done sed -i '1,"$d1"d' Eingabedatei d2=1 echo "ende" sleep 5 while [ $d2 -le $d1 ]; do echo 3"$(eval 'echo $a'$d2)"000 > /dev/ttyUSB1 eval 'c'$d2=$(sed -n $(($d2))p Eingabedatei | tr -dc '0-9') # es hat ohne tr unsichtbare sonderzeichen d2=$(($d2+1)) done while true; do #aktueller Wert anfordern #wenn $d1 Zeilen bekommen, dann while read line, und berechne prozent aus Eingabedatei #sende Befehlskette an /dev/ttyUSB0 sed -i 1,"$d1"d Eingabedatei done |
||||
Anmeldungsdatum: Beiträge: 17548 Wohnort: Berlin |
Wer misst, misst Mist, aber in dem Falle konnte ich die Größenordnung mit eigener Messung nachvollziehen. Womöglich findet anhand von /dev/null eine Optimierung statt, die es erlaubt gleich die nächste Zeile zu lesen.
Und "cat /dev/ttyUSB0 | script.sh" klappt nicht? Oder hängt noch ein Verarbeitungsschritt dazwischen oder müssen die Daten aufbewahrt werden?
Ja, Quoting benutzen viele auf gut Glück. Wenn man nur 2x im Jahr ein Script schreibt kann man da auch nicht gut was anderes empfehlen. ☺
Du musst bedenken, Du schreibst das Script für Dich selbst. Es sieht für Dich wirr aus, weil es wirr ist. Wahrscheinlich schlechtes Design.
Wie sollte es, wenn es wirr ist?
Das ist schlecht, aber ein Anhaltspunkt. Es sollte möglichst wenig von anderen Scripten abhängen und andere Scripte wenig von diesem. Ohne die Wirrnis zu sehen kann man da aber nur raten. Versuch, einzelne Funktionen zu isolieren und wirklich als Funktionen zu definieren. Funktionen, die auch von anderen benötigt werden, auszulagern.
Das war nicht meine Frage.
Der Satz ist unverständlich. Ist "so lange dauert" gemeint?
Doch. ☺ Eval is evil. Niemand benutzt eval. Arrays scheinen eine vielversprechende Alternative, aber ohne den Code zu sehen, ist es schwer was zu sagen. i Die Messwerte sind einfach 50 Zahlen im Bereich 0 bis Irgendwas und werden alle nach dem gl. Schema, aber je nach Wert unterschiedlichen Details abgefertigt? Wieso braucht man da 300 Zeilen? Und was soll dieses a, b? Sind das Temperaturen, Frequenzen, Katzen/Minute oder was? Ist das so geheimnisvoll? Geht es um eine Vibratorsteuerung? Oder hast Du Angst wir klauen Deine Idee, und machen morgen selbst den großen Reibach? |
||||
Projektleitung
Anmeldungsdatum: Beiträge: 12801 |
Das war nicht, was ich meinte. Mit Intervallen meine ich [Min, Max]-Paare.
Ich habe schon verstanden, dass Du Max und Min pro Durchgang bestimmst. Aber es ist immer noch nicht klar, ob Du 50 [Max, Min]-Paare pro Durchlauf hast oder nur eins. Nur, wenn Du mehrere hast, brauchst Du wirklich Arrays. Mir wird das zu unübersichtlich, weil Du offensichtlich schon an einer Lösung arbeitest, während mir die Problemstellung noch nicht klar ist (ich bin anscheinend nicht der einzige) und es mir anscheinend auch nicht gelingt, die passende Erklärung herauszukitzeln.
Ganz schlecht. |
||||
(Themenstarter)
Anmeldungsdatum: Beiträge: 141 |
Uf :O Ich fange mal an zu Antworten und editiere diese Antwort laufend, und setze ans Ende ein "Ende" Aber seht euch das letzte kurz Script an, es ist genau das.
Nicht so richtig, weil es eben mehrere Scripte sind die von einem Haupt Script ab und zu aufgerufen werden, und eines der ersten Scripte ist die Arduino konfiguration, mit dem cat Befehl darin.
Ich meinte für andere sieht es wahrscheinlich wirr aus, ich selbst habe noch knapp den Überblick (-:
Ja Jemand anderes würde wahrscheinlich genau das sagen (-: aber ich schreibe es ja eigentlich auch für mich und nicht jemand anderes. Und nein, es ist weil ich falsch gerechnet und weiter verknüpft habe, und noch etwas auf dem Arduino angepasst habe damit ich die 6er Zahlenblöcke zusammenhängend schicken kann, ohne immer eine Rückmeldung zu bekommen nach jedem einzelnen.
Ja ich scripte halt nicht so wie es für andere gut aussieht, aber für mich selbst ist es so am ansprechendsten, und mit der Zeit lernt man ja auch und verändert seinen Schreibstil, und vorhersehen kann man auch nicht all zu fest.
Es ist jetzt das gekürzte Script unten von mir editiert, da ist es mit 2en gemacht.
Ja 0.4s lang, anstatt 0.02, wie bei der 1. Antwort von dir.
Ja, sah vielversprechend aus, bis ich die Indexe mit Abstand dazwischen wieder heraus bekommen habe. Es sind auch viele Zeilen verschwendet mit Leerzeilen oder #####, am Anfang sind gewisse Sachen auch noch von Hand aufgelistet, ich muss glaube ich sowieso nochmals alles neu überarbeiten, da eben alles nicht mehr so ganz stimmt seit ich auf dem Arduino etwas geändert habe.
Haha (-: Nein es geht nicht um eine Vibratorsteuerung, und man kann damit auch kein Geld machen. Ich wollte nur nicht grad mein unfertiges, für andere wirr aussehende und nicht sauber gelöstes Script hier für alle Ewigkeit verewigen. Der einte Arduino (ttyUSB1) liest die Analog Werte von einem Photowiderstand (der seinen Wert verändert wenn er Licht bekommt), am anderen Arduino hängen Servos. Auf den Photosensor scheint Licht von einer Led über ein Plastik Lichtleiter Kabel, das in der Mitte durchtrennt ist und in einem dünnen Silikonschlauch steckt. Wenn man den Silikon Schlauch biegt, scheint nicht mehr das volle Licht bis zum Photosensor hindurch, und so verändert sich der Wert. Es ist glaube ich einfach nicht proportional, also es ist nicht soo gut geeignet um etwas genau zu messen. Und der Servo soll den Winkel annehmen den der Lichtleiter gerade hat an der durchtrennten Stelle. Und das ist eigentlich auch nur ein Test, ich weiss nicht ob das am Schluss gut funktioniert oder unbrauchbar ist oder bald wieder auseinander fliegt.
Aha, doch es gibt schon gleich viele min max Paare wie aktuelle Werte, max etwa 50 am Schluss
Das stimmt nicht, alle max min Paare werden vor der endlosen while Schleife heraus gesucht, und bleiben dann so bis das Script beendet wird. Nur der aktuelle Wert wird dann dauernd neu abgefragt in der endlosen while Schleife. So wie im neu editierten kurz Script.
Ja (-: aber ich muss nachher mal schauen ob ich printf dazu benutzen kann um $a$d2 herum zu kommen, weil so wie ich das jetzt sehe brauche ich das jetzt nur weil die Servo Zahl die der Arduino braucht 2 stellig ist, und die 2 stellige Zahl in einer anderen Variable gespeichert wird. Bleibt aber doch noch die Frage ob man "a2=$(eval 'echo $a'$v1)" nicht beschleunigen könnte, "eval 'a'$v1=100" geht auch schnell, und echo eigentlich alleine auch, also ich weiss gar nicht wieso das eval echo so lange braucht. Oder alternativ eben wie man alles aus einem Array ohne Abstand dazwischen ausgibt, ohne verlangsamende weiterleitung an andere Befehle. Weil irgendwann später stehe ich sicher wieder an diesem Punkt. ... ENDE Edit: Beide Arduinos erwarten übrigens immer 6er Zahlenblöcke, und eine 7. Zahl die entweder das Endzeichen oder : ist. Wenn die erste Zahl 1 ist bedeutet es Servo Winkel einstellen, wenn die 1. Zahl 3 ist bedeutet es Photosensor auslesen. dann kommt eine 2 stellige Zahl für die Nummer des Servos oder Photosensor, dann 3 Stellen für den Servo Winkel, beim Photosensor bedeuten sie nichts. Und ganz genau gesagt will ich auch prozent von 180 ausrechnen, ich hab das mal jetzt einfachheithalber nicht auch noch dazu gerechnet, weil es ja egal ist ob pro 100 oder pro 180 |
||||
Anmeldungsdatum: Beiträge: 17548 Wohnort: Berlin |
Nein. Und komm nicht auf die Idee das Skript als Anhang anzufügen. Setz es in einen Codeblock.
Arrays sind wie gesagt schneller:
Ohne das Script zu sehen helfen die Erklärungen nichts.
Das siehst Du vollkommen falsch. Wenn Du Skripte für andere schreibst, da kannst Du reinmüllen wie Du lustig bist, aber wenn Du es für Dich selbst schreibst, dann musst Du es sauber formatieren, übersichtlich machen, selbsterklärend, denn Du willst es ja leicht verstehen und überarbeiten können und Du weißt, wer es geschrieben hast. Für sich selbst Müll machen und für andere Herausgeputzes, das ist Heuchelei. Umgekehrt ist es nur Egoismus. |
||||
(Themenstarter)
Anmeldungsdatum: Beiträge: 141 |
Hä? Doch es ist mit 2en gemacht, genau so wie ich es im ganzen Script gemacht habe, nur übersichtlich.
Willst du jetzt wirklich das ganze Script mit allen nicht mehr funktionierenden Teilen, obwohl ich es unten zusammengefasst und verkürzt dargestellt habe? Einen Moment mal, ich füge es nachher an...
Ja aber ich glaube es liegt einfach an dem Problem das echo 12345 0.000s braucht, aber echo $(echo 123456) 0.016 bei mir, auch mit printf. Und irgendwie muss ich am Schluss so etwas am Arduino senden "echo 101100:102050", und das mit max 50 6er Blöcken, und zwar mit dieser Art von Variablen: "echo 1$v1$x1" oder "echo 1$(printf "%02d\n" $v1)$(printf "%03d\n" $v2)". Auch wenn ich ein Array erstelle muss ich printf benutzen wegen der 3er Stelle, oder ich müsste den ganzen Inhalt des Arrays ohne Abstand zwischen den Indexen ausgeben können (soweit ich das jetzt abschätzen kann). Oder wie würdest du aus den Werten in den Variablen wieder 6er Blöcke zusammen bauen?
Das habe ich doch, sicher das du das editierte mit a und b variablen gesehen hast? Wenn dir das nichts sagt dann sollte dir eben das richtige Script erst recht nichts sagen, ich meine eben, jemand der es nicht selbst geschrieben hat kommt nicht gut draus ohne das tagelang zu studieren. Ich füge es nachher mal an.
Klingt mir nach einer unglaublichen Kollegschaft 😀 Aber für mich ist es ok formatiert. Eigentlich sieht es gar nicht so schlecht aus, es ist einfach komplex aufgebaut, und es nützt dir nichts wenn du nicht weisst was gedacht wurde beim erstellen und machen all dieser Variablen, denke ich mal. Sonst sollte das editierte kurz Script eigentlich schon alles aussagen... Aber warte mal kurz... |
||||
(Themenstarter)
Anmeldungsdatum: Beiträge: 141 |
#!/bin/bash a1="/pfad/zum/hauptordner" # haupt ordner a2="/dev/ttyUSB0"; # arduino port (1) a3="nächster ordner pfad" # nächster ordner a4="10" # gpio pin für servo strom ein a8="$a1/speicher" a9="$a8/speicher4" a10="/dev/ttyUSB1"; # 2. arduino port d1=01 # photosensor 1 d2=02 # photosensor 1 d3=03 # photosensor 1 d4=04 # photosensor 1 d5=05 # photosensor 1 d6=06 # photosensor 1 e1=6 # anzahl photosensoren e2=5 # verzögerungs zeit e3=1 # aktuellem photosensor variabel zahl für schleife e4=3 # aufzähl variable für sensor wert aufnahme, und werte aus arduino speicher holen e5=301000 # erster sensor abfrage befehl, für auflistung aller arduino2 befehle in einem satz e6=101000 # variable für servo befehle zusammen an arduino senden # alle f variablen sind für photosensor wert aufnahme min reserviert, gleiche anordnung wie d variablen # alle g variablen sind für photosensor wert aufnahme max reserviert, gleiche anordnung wie d variablen # alle h variablen sind für differenz zwischen f und g # alle i variablen sind für + oder -, bei differenz zwischen f und g, wird nur i=f oder g gesetzt # alle j variable sind für servo winkel befehl an arduino1 senden ###################################################################################################################### ###################################################################################################################### # 2. arduino verbinden echo "" echo "verbinde 2. arduino" pfad/zum/script* # 2. arduino verbinden sleep 3 echo 000000 > $a10 # weil nach neustart vom arduino die erste rückmeldung alles überschreibt, sonst stimmt die reihenfolge nicht sleep 1 # sleep zeit zu erster start obige zeile echo "" echo "fertig" ###################################################################################################################### # aufnahme der sensor werte min und max echo "beginne" ########################### echo "min start" echo "erfasse werte" sleep $e2 ########################### echo "0" > $a8/speicher3 # arduino kommunikations speicher leeren echo 3"$d1"000 > $a10 echo 3"$d2"000 > $a10 echo 3"$d3"000 > $a10 echo 3"$d4"000 > $a10 echo 3"$d5"000 > $a10 while [ true ]; do if [ "$(wc -l $a8/speicher3 | cut -d" " -f1)" -lt 11 ]; then # warten bis 2. arduino speicher alle zeilen erhalten hat, und fertig sleep 0.001 else break fi done f1=$(sed -n 3p $a8/speicher3 | tr -dc '0-9') # alle min sensor werte aufnehmen in f variablen, tr weil noch unsichtbare zeichen a sind f2=$(sed -n 5p $a8/speicher3 | tr -dc '0-9') f3=$(sed -n 7p $a8/speicher3 | tr -dc '0-9') f4=$(sed -n 9p $a8/speicher3 | tr -dc '0-9') f5=$(sed -n 11p $a8/speicher3 | tr -dc '0-9') ########################### echo "" echo "min werte aufgenommen" echo "" echo "max start" echo "erfasse werte" sleep $e2 ########################### echo "0" > $a8/speicher3 # arduino kommunikations speicher leeren echo 3"$d1"000 > $a10 echo 3"$d2"000 > $a10 echo 3"$d3"000 > $a10 echo 3"$d4"000 > $a10 echo 3"$d5"000 > $a10 while [ true ]; do if [ "$(wc -l $a8/speicher3 | cut -d" " -f1)" -lt 11 ]; then # warten bis 2. arduino speicher alle zeilen erhalten hat, und fertig sleep 0.001 else break fi done g1=$(sed -n 3p $a8/speicher3 | tr -dc '0-9') # alle min sensor werte aufnehmen in g variablen, tr weil noch unsichtbare zeichen da sind g2=$(sed -n 5p $a8/speicher3 | tr -dc '0-9') g3=$(sed -n 7p $a8/speicher3 | tr -dc '0-9') g4=$(sed -n 9p $a8/speicher3 | tr -dc '0-9') g5=$(sed -n 11p $a8/speicher3 | tr -dc '0-9') ########################### echo "" echo "max werte aufgenommen" echo "" echo "min start" echo "erfasse werte" sleep $e2 ########################### echo "0" > $a8/speicher3 # arduino kommunikations speicher leeren echo 3"$d1"000 > $a10 while [ true ]; do if [ "$(wc -l $a8/speicher3 | cut -d" " -f1)" -lt 3 ]; then # warten bis 2. arduino speicher alle zeilen erhalten hat, und fertig sleep 0.001 else break fi done f6=$(sed -n 3p $a8/speicher3 | tr -dc '0-9') # alle min sensor werte aufnehmen in f variablen, tr weil noch unsichtbare zeichen da sind ########################### echo "" echo "min werte aufgenommen" echo "" echo "max start" echo "nehme werte auf" sleep $e2 ########################### echo "0" > $a8/speicher3 # arduino kommunikations speicher leeren echo 3"$d1"000 > $a10 while [ true ]; do if [ "$(wc -l $a8/speicher3 | cut -d" " -f1)" -lt 3 ]; then # warten bis 2. arduino speicher alle zeilen erhalten hat, und fertig sleep 0.001 else break fi done g6=$(sed -n 3p $a8/speicher3 | tr -dc '0-9') # alle min sensor werte aufnehmen in g variablen, tr weil noch unsichtbare zeichen da sind ########################### echo "" echo "alle werte aufgenommen" echo "" ###################################################################################################################### ### vor rechnen für haupt script echo "" echo "berechne..." # unterschied zwischen f und g ausrechnen e3=1 # variable zurücksetzen, variablen zahl aufzählung für while while [ $e3 -le $e1 ]; do if [ $(eval 'echo $f'$e3) -lt $(eval 'echo $g'$e3) ]; then # wenn f < g, dann g-f und i=f, sonst umgekehrt eval 'h'$e3=$(( $(eval 'echo $g'$e3) - $(eval 'echo $f'$e3) )) eval 'i'$e3=$(eval 'echo $f'$e3) elif [ $(eval 'echo $g'$e3) -lt $(eval 'echo $f'$e3) ]; then eval 'h'$e3=$(( $(eval 'echo $f'$e3) - $(eval 'echo $g'$e3) )) eval 'i'$e3=$(eval 'echo $g'$e3) else echo "" echo "ERROR" fi e3=$(($e3+1)) # aufzählungsvariable +1 done # sensor befehls abfrage in einem satz ausrechnen e3=2 # variable auf passenden wert zurücksetzen für while while [ $e3 -le $e1 ]; do e5="$e5":3"$(eval 'echo $d'$e3)"000 e3=$(($e3+1)) done echo "" echo "fertig" ###################################################################################################################### ###################################################################################################################### ### haupt script # vorgängig echo "0" > $a8/speicher3 # arduino kommunikations speicher leeren sed -i '1d' $a8/speicher3 # einzige zeile aus speicher3 löschen echo "$e5" > $a10 # vorgängige sensor wert abfrage while [ true ]; do echo "$e5" > $a10 # sensor wert abfrage e3=1 # variable zurücksetzen für while while read -r line; do # while read = if arduino speicher (speicher3) > 50 (e3) zeilen if [ $e3 = 1 ]; then eval 'j'$e1=$line # rechnung $e3=$(($e3+1)) done < $a8/speicher3 e3=1 # variable zurücksetzen, variablen zahl aufzählung für while echo "0" > $a8/speicher3 # arduino kommunikations speicher leeren while [ $e3 -le $e1 ]; do echo 3"$(eval 'echo $d'$e3 )"000 > $a10 ################################### <--- dieser befehl muss von hand aufgezählt werden ohne schleife mit / zwischen zahlen e3=$(($e3+1)) # aufzählungsvariable +1 echo "send" date +%S.%N echo 3"$(eval 'echo $d'$e3 )"000 done #echo "send" #date +%S.%N # sensor werte aus arduino speicher lesen, in prozent umwandeln und winkel befehl senden e3=3 # variable zurücksetzen auf erste zeile von sensor wert aus arduino speicher, variablen zahl aufzählung für while while [ $e3 -le $(($e1*2+1)) ]; do # wenn aktueller sensor/winkel max anzahl an sensoren/winkel überschreitet, *2 +1 weil asl erstes 0 zum überschreiben geschrieben wird, und dann 2 zeilen für jeden sensor wert (0 antwort, und wert) echo "empfang" date +%S.%N e4=$(sed -n $(($e3))p $a8/speicher3 | tr -dc '0-9') # sensor wert in variable speichern aus 2. arduino speicher, tr weil unsichtbare zeichen sonst vorhanden sind echo " $e4" #echo "1"$(eval 'echo $d'$(($(($e3-1))/2)) ) #echo $(printf "%03d\n" "$(($(( 180000000/$(eval 'echo $h'$(( $(($e3-1)) /2)) ) * $(($e4 - $(eval 'echo $i'$(( $(($e3-1)) /2)) ) )) )) /180000))") echo "befehl: $(echo "1"$(eval 'echo $d'$(($(($e3-1))/2)) )""$(printf "%03d\n" "$(($(( 180000000/$(eval 'echo $h'$(( $(($e3-1)) /2)) ) * $(($e4 - $(eval 'echo $i'$(( $(($e3-1)) /2)) ) )) )) /1000000))")"" )" echo "1"$(eval 'echo $d'$(($(($e3-1))/2)) )""$(printf "%03d\n" "$(($(( 180000000/$(eval 'echo $h'$(( $(($e3-1)) /2)) ) * $(($e4 - $(eval 'echo $i'$(( $(($e3-1)) /2)) ) )) )) /1000000))")"" > $a2 # rechnen und winkel befehl senden, printf weil nur so ist winkel zahl immer 3 stellig e3=$(($e3+2)) # aufzählungsvariable +1 done #echo "empfang" #date +%S.%N done killall cat # cat wegen 2. arduino beenden $a1/scripte/2.* # 1. arduino wieder verbinden und cat neu starten Das ist das richtige Script, ein paar wenige Pfade am Anfang neutralisiert, und 1 2 auskommentierte Gedanken entfernt. Ich dachte eigentlich nicht das ich das jemals öffentlich mache. Es ist eigentlich gar nicht schlecht dargestellt, eigentlich sehr schön. Nur ob da noch jemand draus kommt bei all der Rechnerei mit überall Variablen, glaub ich eher nicht. Würde mich jetzt überraschen wenn da jemand noch besser draus kommt als bei dem kurz zusammengefassten. Ich habe auch im Haupt Script Abschnitt angefangen etwas hinein zu schieben, was noch nicht fertig ist, evtl sogar 2x. Und es wäre so gedacht dass ich mit der Zeit immer mehr Variablen aufliste und so mehr Servos hinzugefügt werden, jetzt sind es erst 6, ich habe mir einfach als max Grenze mal 50 gesetzt, so viele Sensorwerte sollte es in max 0.1s an den 2. Arduino weiter leiten können. |
||||
(Themenstarter)
Anmeldungsdatum: Beiträge: 141 |
Ich würde es aber gar nicht versuchen da noch eine Überblick heraus zu finden. Besser in dem kurz zusammen gefassten. Ich hänge es nochmals an, falls es jemand übersehen hat. a1=01 a2=02 b1=0 b2=0 c1=0 c2=0 d1=2 # max Anzahl an Werten (b und c und aktueller wert) d2=1 echo "anfang" sleep 5 while [ $d2 -le $d1 ]; do echo 3"$(eval 'echo $a'$d2)"000 > /dev/ttyUSB1 eval 'b'$d2=$(sed -n $(($d2))p Eingabedatei | tr -dc '0-9') # es hat ohne tr unsichtbare sonderzeichen d2=$(($d2+1)) done sed -i '1,"$d1"d' Eingabedatei d2=1 echo "ende" sleep 5 while [ $d2 -le $d1 ]; do echo 3"$(eval 'echo $a'$d2)"000 > /dev/ttyUSB1 eval 'c'$d2=$(sed -n $(($d2))p Eingabedatei | tr -dc '0-9') # es hat ohne tr unsichtbare sonderzeichen d2=$(($d2+1)) done while true; do #aktueller Wert anfordern #wenn $d1 Zeilen bekommen, dann while read line, und berechne prozent aus Eingabedatei #sende Befehlskette an /dev/ttyUSB0 sed -i 1,"$d1"d Eingabedatei done |
||||
(Themenstarter)
Anmeldungsdatum: Beiträge: 141 |
Ah ja, und ich könnte mir vorstellen das es für die Hälfte meiner Befehle eine bessere einfachere Variante gibt, aber ich kann es halt nur so, und für mich funktioniert es auch mehr oder weniger bis jetzt. Nur wieso echo 123456 so viel schneller ist als "echo $(echo 123456)" verstehe ich nicht wirklich, das macht es zunichte. Vielleicht könnte man das ganze Script viel einfacher darstellen, es ist etwa die 30. Abänderung, angefangen bei einem anderen Script. Also ich stecke eigentlich mitten in einem Versuch etwas zu machen, es ist sicher nichts gekürzt und überarbeitet, ich wollte nur endlich mal sehe ob die Servos sich so bewegen wie ich es erhoffe, und dabei habe ich gemerkt das es mit 1 Servo schon ca 0.2s Verzögerung hat, und theoretisch mit 50 im Moment irgendwie 0.5s. Und ich nehme an das es noch weitere 10 20 Abänderungen werden würden bis dieser Teil endlich mal vorläufig (für mich) funktioniert. Und dann könnte sicher jeder von euch das noch 10x einfacher machen. Ich halt aber nicht, und ich wollte auch nicht grad eine neue Sprache lernen, wenn ich all halb Jahr wieder mal das letzte Script für voraussichtlich Monate mache. |