user_unknown
Anmeldungsdatum: 10. August 2005
Beiträge: 17552
Wohnort: Berlin
|
ka111 schrieb: Am besten probierst Du das in einem separaten Testscript, bis klappt.
Das mache ich eigentlich auch, dazu werden 2 andere Scripte gestartet die die beiden Arduinos konfigurieren und mit '"cat /dev/ttyUSB0 > Eingabedatei &"' das in die Eingabedatei lenken. Aber wenn sie gelöscht wird von sed funktioniert es nachher nicht mehr. Jedenfalls bekomme ich einfach nichts mehr wenn ich mit sed Zeilen heraus lösche, aber überschreiben mit echo oder direkt nur > geht.
Ich muss sagen, dass ich den Überblick verloren habe, an welcher Stelle das ist. Praktisch wäre es, wenn Du einen Beispielcode hast, der nur dieses Problem isoliert zeigt. Meist findet man auf dem Weg der Isolation des Problems übrigens selbst die Lösung, weil irgendwann ein Vereinfachungsschritt kommt, und dann das Problem weg ist, und dann weiß man, an welcher Stelle man ansetzen muss.
Sed -i eignet sich nicht für das Lesen von einer /dev-Datei, über die ein Datenstrom reinkommt. Allerdings fand ich in Deinem Script nur eine Verwendung von port1 (USB0), schreibend und etwa ein Dutzend für port2 (USB1), aber auch alle schreibend.
Ja, Arduino 1 wird vor diesem Script schon gestartet, und das Script für Arduino 2 wird von diesem Script gestartet am Anfang. Danach beinhaltet speicher3 alles vom 2. Arduino tty. Aber Befehle an die 2 muss ich halt immer noch über den Port senden.
geht glaube ich nicht, weil es wird mehrmals s=$(print) gemacht, was eben komischerweise viel länger geht als s=1 oder einfach nur print ..., wie eben auch echo $(echo ...) viel länger geht als einfach nur echo.
Das verstehe ich nicht (Satzbau, Grammatik).
Es wird nicht einfach s=$(print ...) gemacht, sondern s=$s$(print ...) - vielleicht hast Du das schon mal bei der Pfadvariablen gesehen: PATH=/home/ka111/bin:$PATH - die Variable wird um einen eigenen String verlängert; sie wird hinten noch mal zugefügt aber dem gleichen Namen wieder zugewiesen.
Ja das habe ich schon verstanden dass es immer verlängert wird, ich meinte einfach das: 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35 | time echo 123456
123456
real 0m0.000s
user 0m0.000s
sys 0m0.000s
time echo $(echo 123456)
123456
real 0m0.007s
user 0m0.005s
sys 0m0.002s
time v1=1
real 0m0.000s
user 0m0.000s
sys 0m0.000s
time v1=$(echo 1)
real 0m0.007s
user 0m0.005s
sys 0m0.002s
time v1=$(($v1+100-50*5/5))
real 0m0.000s
user 0m0.000s
sys 0m0.000s
|
Beispiele sind immer gut, aber ein Satz, was gezeigt werden soll (Verschachtelte echos, nehme ich an), ist trotzdem nicht schlecht - das ist ja keine Quizshow hier.
Das selbe auch mit printf. Deshalb kann ich '"s="$s"$(printf "foo-%03d-bar\t" $i )"' nicht machen in einer Schleife.
Ja, ich glaube das ist an einer Stelle im Script, die ich noch nicht überarbeitet hatte. Ich wollte die komplexen Stellen aufschieben, bis die einfacheren geklärt sind. Wahrscheinlich ist barfoot=$(echo $(echo $foobar) $baz)) gar nicht nötig.
Und
| ksl2 () {
echo "0" > /tmp/muell
for i in {1..5}
do
echo -n 3${sensor[i]}000
done > $port2
}
|
Geht auch nicht, das hat aber etwas mit dem tty zu tun, ich kann auch am tty nicht X mal einzeln mit echo etwas senden, das geht dann irgendwie auch wieder länger, aber das hat jetzt mit dem tty zu tun. Es sieht so aus als ob es Zeit kostet die Kommunikation mit tty anzufangen, aber wenn sie mal angefangen wurde braucht es nicht mehr so lange um noch mehr Zeichen zu senden.
Ja, eine Datei öffnen, was reinschreiben, schließen und das 5x neu dauert wahrscheinlich meist länger als einmal öffnen, 5x schreiben und dann schließen oder erst den String oder Bytebuffer zusammenzusetzen, den man auf einen Rutsch dann schreibt, wenn er fertig ist. Das ist aber sehr kontextabhängig, was was schnell/schnell genug ist und oft abhängig davon, ob man etwas 5x macht, 50x oder 50 Millionen mal.
Edit: Solche Zeilen müssen in einen Codeblock, oder zwischen Backticks: Siehe: '"printf ..."'
Ich hatte das auch versucht bei dem, aber es hat nichts genützt, oder welche Zeichen muss ich verwenden? Diese ' ? Die haben irgendwo geholfen aber bei printf nicht, sah aber grad gut aus.
Also hier im Forum im Fließtext, nicht in den Scripten, kannst Du einzelne, kurze Codefragmente mit einfachen Backticks einkapseln, die leicht verwechselt werden könnenn mit dem Apostroph. Statt Backtick kann man auch sagen Accent-Grave, wenn man besser Französisch kann als ich, der es bestimmt falsch geschrieben hat, also dieses Accentzeichen, das da steht, wo auch jenes steht, das man über ein Café setzt, nur dass es abfällt, nicht ansteigt, und man daher die Shifttaste zusätzlich bemühen muss. Hacker haben oft die Tastatur so eingestellt, dass es direkt erscheint, wenn man es tippt. Wer oft franz. Namen tippen muss hat es aber als Dead-Grave eingestellt. Dann passiert erst mal nichts, wenn man es tippt, aber wenn der nächste Buchstabe einer ist, der das Zeichen konsumieren kann, wie aeuoAEUO, dann wird letzteres damit dekoriert. Folgt ein Zeichen, welches keinen Accent mag, z.B. die Leertaste, kommt das Zeichen solo und kann Maskierungsaufgaben übernhmen.
|
ka111
(Themenstarter)
Anmeldungsdatum: 22. Juni 2014
Beiträge: 141
|
user_unknown > Am besten probierst Du das in einem separaten Testscript, bis klappt.
> Das mache ich eigentlich auch, dazu werden 2 andere Scripte gestartet die die beiden Arduinos konfigurieren und mit '"cat /dev/ttyUSB0 > Eingabedatei &"' das in die Eingabedatei lenken. Aber wenn sie gelöscht wird von sed funktioniert es nachher nicht mehr. Jedenfalls bekomme ich einfach nichts mehr wenn ich mit sed Zeilen heraus lösche, aber überschreiben mit echo oder direkt nur > geht.
Ich muss sagen, dass ich den Überblick verloren habe, an welcher Stelle das ist. Praktisch wäre es, wenn Du einen Beispielcode hast, der nur dieses Problem isoliert zeigt. Meist findet man auf dem Weg der Isolation des Problems übrigens selbst die Lösung, weil irgendwann ein Vereinfachungsschritt kommt, und dann das Problem weg ist, und dann weiß man, an welcher Stelle man ansetzen muss.
Die nächste Antwort dient auch grad zum Verständnis: ...
Sed -i eignet sich nicht für das Lesen von einer /dev-Datei, über die ein Datenstrom reinkommt. Allerdings fand ich in Deinem Script nur eine Verwendung von port1 (USB0), schreibend und etwa ein Dutzend für port2 (USB1), aber auch alle schreibend.
Ja, Arduino 1 wird vor diesem Script schon gestartet, und das Script für Arduino 2 wird von diesem Script gestartet am Anfang. Danach beinhaltet speicher3 alles vom 2. Arduino tty. Aber Befehle an die 2 muss ich halt immer noch über den Port senden.
Also der 1. Arduino ist bereits gestartet wenn dieses Script aufgerufen wird. Und der 2. Arduino wird ganz am Anfang, eben mit einer Variable im Pfad gestartet. Diese Zeile wäre das gewesen, die startet ein kleines anderes Script das den Arduino konfiguriert, und mit cat & von tty zu speicher3 umleitet: | $a1/scripte/6.* # 2. arduino verbinden
|
Beispiele sind immer gut, aber ein Satz, was gezeigt werden soll (Verschachtelte echos, nehme ich an), ist trotzdem nicht schlecht - das ist ja keine Quizshow hier.
Manchmal könnte ich mich fragen ob das bei Dir auch so dargestellt wird wie ich das sehe, aber es steht doch da bei dem Code mit den verschiedenen time's? Du hast ja das Beispiel mit s=$s$(print ...) gemacht, ich glaube in einer Schleife. Und wie man bei den verschiedenen time Beispielen sieht, geht das zu lange, es dauert zu lange. Es ist das selbe wie time v1=$(echo 1) . Sobald eine Variable gesetzt wird, mit einem Befehl in Klammern, dauert es zu lange. Ich weiss nicht wieso, es ist aber so. Genau gleich auch einen echo oder printf Befehl, mit wieder einem Befehl in Klammern, geht auch zu lange. Also darf es nicht gemacht werden mit einem Befehl in Klammern, es kann gerechnet werden, Variablen benutzt werden, und 1 printf oder echo Befehl am Schluss. Das wäre dann eben dieser printf Befehl: | printf "1${d[1]}%03d:1${d[2]}%03d:1${d[3]}%03d:1${d[4]}%03d:1${d[5]}%03d:1${d[6]}%03d:" "${j[1]}" "${j[2]}" "${j[3]}" "${j[4]}" "${j[5]}" "${j[6]}" > /dev/ttyUSB1
|
Das selbe auch mit printf. Deshalb kann ich '"s="$s"$(printf "foo-%03d-bar\t" $i )"' nicht machen in einer Schleife.
Ja, ich glaube das ist an einer Stelle im Script, die ich noch nicht überarbeitet hatte. Ich wollte die komplexen Stellen aufschieben, bis die einfacheren geklärt sind. Wahrscheinlich ist barfoot=$(echo $(echo $foobar) $baz)) gar nicht nötig.
Und das würde dann eher wieder bedeuten das wir aneinander vorbei reden, das wollte ich mit den time Befehlen erklären, zu deiner Frage oben.
>Geht auch nicht, das hat aber etwas mit dem tty zu tun, ich kann auch am tty nicht X mal einzeln mit echo etwas senden, das geht dann irgendwie auch wieder länger, aber das hat jetzt mit dem tty zu tun. Es sieht so aus als ob es Zeit kostet die Kommunikation mit tty anzufangen, aber wenn sie mal angefangen wurde braucht es nicht mehr so lange um noch mehr Zeichen zu senden.
Ja, eine Datei öffnen, was reinschreiben, schließen und das 5x neu dauert wahrscheinlich meist länger als einmal öffnen, 5x schreiben und dann schließen oder erst den String oder Bytebuffer zusammenzusetzen, den man auf einen Rutsch dann schreibt, wenn er fertig ist.
Ja, das noch dazu, aber es hat auch wirklich etwas mit dem tty zu tun, in eine andere normale Datei kann ich viel schneller 50x einen echo Befehl senden als nach ttyUSB0.
Also hier im Forum im Fließtext, nicht in den Scripten, kannst Du einzelne, kurze Codefragmente mit einfachen Backticks einkapseln, die leicht verwechselt werden könnenn mit dem Apostroph. Statt Backtick kann man auch sagen Accent-Grave, wenn man besser Französisch kann als ich, der es bestimmt falsch geschrieben hat, also dieses Accentzeichen, das da steht, wo auch jenes steht, das man über ein Café setzt, nur dass es abfällt, nicht ansteigt, und man daher die Shifttaste zusätzlich bemühen muss. Hacker haben oft die Tastatur so eingestellt, dass es direkt erscheint, wenn man es tippt. Wer oft franz. Namen tippen muss hat es aber als Dead-Grave eingestellt. Dann passiert erst mal nichts, wenn man es tippt, aber wenn der nächste Buchstabe einer ist, der das Zeichen konsumieren kann, wie aeuoAEUO, dann wird letzteres damit dekoriert. Folgt ein Zeichen, welches keinen Accent mag, z.B. die Leertaste, kommt das Zeichen solo und kann Maskierungsaufgaben übernhmen.
Aha, also die gespiegelte Version von dem ´? Ich dachte zwar das hätte ich auch ausprobiert und hat nichts genützt, aber vielleicht habe ich auch die 2 verwechselt und das gespiegelte probiert. Ich probiere es in Zukunft aus mit diesen Strichen.
|
ka111
(Themenstarter)
Anmeldungsdatum: 22. Juni 2014
Beiträge: 141
|
Also falls sich jetzt noch jemand fragt wie das Script am Schluss aussah, es ist jetzt mal vorläufig fertig. Vor dem Hauptscript gibt es eigentlich keine besonderen Änderungen, nur auf Arrays umgeschrieben und die Zeilenanzahl vom Arduino angepasst, so in etwa. Und ab Hauptscript ist es jetzt neu, mit einer kurzen (0.001s) read Abfrage, um noch interagieren zu können, aber mehr als Pause oder beenden habe ich noch nicht gemacht. Ich würde jetzt aber trotzdem nicht empfehlen das nochmals genau durchzuschauen, es ist immer noch gleich unverständlich für jemand der es nicht selbst geschrieben hat, nur so falls es jetzt noch jemand interessiert hat wie es am Schluss aussah. Und verbessert muss auch nichts mehr werden (-: 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342 | bin/bash
# a1 - a15 sind Pfade, a2 = 1.Arduino Port, a10 = 2. Arduino Port
declare -A d
d[1]=01 # photosensor 1
d[2]=02 # photosensor 1
d[3]=03 # photosensor 1
d[4]=04 # photosensor 1
d[5]=05 # photosensor 1
d[6]=06 # photosensor 1
e1=1 # 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
e7=0 # read variable um mit script zu ineragieren, ganz zu unterst
e8="Folgende Tasten stehen zur verfügung:
q = beenden
p = weiter und pause beenden
" # text was bei read unterbrechung ausgegeben werden soll, erklärung welche tasten was bewirken
declare -A f
# alle f variablen sind für photosensor wert aufnahme min reserviert, gleiche anordnung wie d variablen
declare -A g
# alle g variablen sind für photosensor wert aufnahme max reserviert, gleiche anordnung wie d variablen
declare -A h
# alle h variablen sind für differenz zwischen f und g
declare -A i
# alle i variablen sind für + oder -, bei differenz zwischen f und g, wird nur i=f oder g gesetzt
declare -A j
# alle j variable sind reserviert, und der ausgerechnete winkel wert, der an arduino1 gesendet wird
######################################################################################################################
######################################################################################################################
### 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"
###########################
### rechte hand
echo "min start"
echo "erfasse werte"
sleep $e2
###########################
echo "0" > $a8/speicher3 # arduino kommunikations speicher leeren
echo 3"${d[1]}"000:3"${d[2]}"000:3"${d[3]}"000:3"${d[4]}"000:3"${d[5]}"000 > $a10 # photosensor 1-5 wert anfordern
while [ true ]; do
if [ "$(wc -l $a8/speicher3 | cut -d" " -f1)" -le 5 ]; then # warten bis 2. arduino speicher alle zeilen erhalten hat, und fertig
sleep 0.001
else break
fi
done
e3=1 # zähler variable
while read -r line; do # 5 sensor werte aufnehemn
if ! [ $e3 = 1 ]; then
f[$(($e3-1))]=$(echo $line | tr -dc '0-9') # alle min sensor werte aufnehmen in f variablen, tr weil noch unsichtbare zeichen da sind, -1 weil 1. zeile 0 ist von arduino speicher leeren
fi
if [ $e3 = 6 ]; then # wenn mehr als 5 sensor werte aufgenommen, dann abbrechen. 6 weil 1. zeile 0 ist
break
fi
e3=$(($e3+1)) # zähler variable +1
done < $a8/speicher3
###########################
echo ""
echo "min werte aufgenommen"
echo ""
echo "max start"
echo "erfasse werte"
sleep $e2
###########################
echo "0" > $a8/speicher3 # arduino kommunikations speicher leeren
echo 3"${d[1]}"000:3"${d[2]}"000:3"${d[3]}"000:3"${d[4]}"000:3"${d[5]}"000 > $a10 # photosensor 1-5 wert anfordern
while [ true ]; do
if [ "$(wc -l $a8/speicher3 | cut -d" " -f1)" -le 5 ]; then # warten bis 2. arduino speicher alle zeilen erhalten hat, und fertig
sleep 0.001
else break
fi
done
e3=1 # zähler variable
while read -r line; do # 5 sensor werte aufnehemn
if ! [ $e3 = 1 ]; then
g[$(($e3-1))]=$(echo $line | tr -dc '0-9') # alle max sensor werte aufnehmen in f variablen, tr weil noch unsichtbare zeichen da sind, -1 weil 1. zeile 0 ist von arduino speicher leeren
fi
if [ $e3 = 6 ]; then # wenn mehr als 5 sensor werte aufgenommen, dann abbrechen. 6 weil 1. zeile 0 ist
break
fi
e3=$(($e3+1)) # zähler variable +1
done < $a8/speicher3
###########################
echo ""
echo "max werte aufgenommen"
echo ""
echo "min start"
echo "erfasse werte"
sleep $e2
###########################
echo "0" > $a8/speicher3 # arduino kommunikations speicher leeren
echo 3"${d[6]}"000 > $a10
while [ true ]; do
if [ "$(wc -l $a8/speicher3 | cut -d" " -f1)" -lt 2 ]; then # warten bis 2. arduino speicher alle zeilen erhalten hat, und fertig
sleep 0.001
else break
fi
done
f[6]=$(sed -n 2p $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"${d[6]}"000 > $a10
while [ true ]; do
if [ "$(wc -l $a8/speicher3 | cut -d" " -f1)" -lt 2 ]; then # warten bis 2. arduino speicher alle zeilen erhalten hat, und fertig
sleep 0.001
else break
fi
done
g[6]=$(sed -n 2p $a8/speicher3 | tr -dc '0-9') # alle max sensor werte aufnehmen in g variablen, tr weil noch unsichtbare zeichen da sind
###########################
echo ""
echo "alle werte aufgenommen"
######################################################################################################################
### vor rechnen für haupt script
echo ""
echo "berechne..."
#echo ${f[1]}.${g[1]} ################################################################################################################################################################################
# unterschied zwischen f und g ausrechnen
e3=1 # variable zurücksetzen, variablen zahl aufzählung für while
while [ $e3 -le $e1 ]; do
if [ "${f[$e3]}" -lt "${g[$e3]}" ]; then # wenn f < g, dann g-f und i=f, sonst umgekehrt
h[$e3]=$(("${g[$e3]}" - "${f[$e3]}"))
i[$e3]="${f[$e3]}"
elif [ "${g[$e3]}" -lt "${f[$e3]}" ]; then
h[$e3]=$(("${f[$e3]}" - "${g[$e3]}"))
i[$e3]="${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, 2 weil 1x e5 schon richtig gesetzt wurde am anfang
while [ $e3 -le $e1 ]; do
e5="$e5":3"${d[$e3]}"000
e3=$(($e3+1))
done
echo ""
echo "fertig"
######################################################################################################################
######################################################################################################################
echo ""
echo "drücke p für pause und optionen menu"
### haupt script
# vorgängig
>$a8/speicher3 # arduino kommunikations speicher leeren
echo "$e5" > $a10 # vorgängige sensor wert abfrage
while [ true ]; do
# if zeilen > e1; then lesen und prozent winkel ausrechnen
while [ true ]; do
e3=1 # variable zurücksetzen für while
while read -r line; do # while read = if arduino speicher (speicher3) > 50 (e1) zeilen
# j array = zeile - i array * 180 / h array (differenz)
j[$e3]=$(( $(("${line//[^0-9]/}"-"${i[$e3]}")) * 180 / "${h[$e3]}" )) # rechnung entsprechender servo winkel prozentmässig ausrechnen, line//[... weil unsichtbare zeichen da sind, und damit sind es weniger und es funktioniert zum rechnen
e3="$((e3+1))" # zähler variable +1
if [ $e3 -gt $e1 ]; then # wenn zähler variable grösser als max anzahl sensoren/servos, dann abbrechen
break
fi
done < $a8/speicher3
if [ $e3 -gt $e1 ]; then # wenn alle zeilen vorhanend, nicht nochmals versuchen
break
fi
done
>$a8/speicher3 # arduino kommunikations speicher leeren
echo "$e5" > $a10 # sensor wert abfrage
# befehl an arduino1 senden
###########################################################################################################################################################################################################################################################################################################################################################
# printf 1 | d array | %o3d | : am ende / | | j array #################################################################################################################################################################################################
#printf "1${d[1]}%03d:1${d[2]}%03d:1${d[3]}%03d:1${d[4]}%03d:1${d[5]}%03d:1${d[6]}%03d:" "${j[1]}" "${j[2]}" "${j[3]}" "${j[4]}" "${j[5]}" "${j[6]}" > $a2 # befehls code block ausgerechneter winkel prozent an arduino1 senden, muss von hand erweitert werden, aktuell 6 servos ############################################################
printf "1${d[1]}%03d:1${d[2]}%03d:" "${j[1]}" "${j[2]}" > $a2
###########################################################################################################################################################################################################################################################################################################################################################
#printf "%03d" "${j[1]}" | wc -m
read -n 1 -t 0.001 e7 # read teil, um mit script zu interagieren
if [ "$e7" = p ] || [ "$e7" = q ]; then # wenn p oder q gedrückt wird, pause mit read
clear
echo ""
echo "$e8"
sleep 1
while [ true ]; do # read menu schleife
read -n 1 e7
if [ "$e7" = q ]; then # q = beenden
clear
echo ""
echo "Beende"
break 2 # entkomme 2 schleifen
elif [ "$e7" = p ]; then # p = pause beenden
clear
echo ""
echo "beende pause"
break
#elif
fi
clear
echo ""
echo "$e8"
sleep 1
done
fi
done
killall cat # cat wegen 2. arduino beenden
$a1/scripte/2.* # 1. arduino wieder verbinden und cat neu starten
sleep 3
echo 000000 > $a2 # weil nach neustart vom arduino die erste rückmeldung alles überschreibt, sonst stimmt die reihenfolge nicht
sleep 1 # sleep zu obige zeile
# arduino max serial buffer nicht ausreichend für mehr servos
|
Ich habe es bis jetzt nur mit einem Servo getestet, weil ohne zusätzliche Fotosensoren ist vielleicht die Zahl die 3 stellig sein sollte 4 stellig, und dann stimmt die Reihenfolge nicht mehr und es geht nichts mehr. Aber mit einem Servo funktionierte es recht gut für kurze Zeit, der Servo hat sich ziemlich verzögerungsfrei bewegt. Somit wäre das Problem gelöst. Danke allen für die Hilfe und viele Unterstützung.
|
rklm
Projektleitung
Anmeldungsdatum: 16. Oktober 2011
Beiträge: 12834
|
ka111 schrieb: Also falls sich jetzt noch jemand fragt wie das Script am Schluss aussah, es ist jetzt mal vorläufig fertig.
Ich bin nur bis Zeile 22 gekommen. 6 bis 11 erscheint völlig unnötig, weil der Wert jeweils nur der Wert des Index mit führenden Nullen auf zwei Stellen aufgefüllt ist. So etwas kann man leichter berechnen (printf '%02d' $n ). Die Variablen e1 bis e8, die aufgrund ihrer Benennung wie ein Array aussehen, enthalten völlig unterschiedliche Werte. Sprechende und vor allem unterschiedliche Variablennamen wären besser, aber Du scheinst generell ein Faible für einbuchstabige Variablennamen zu haben. Das ist OK bei Schleifenvariablen, solange der Schleifenrumpf kurz ist, aber sie so über ein komplettes Skript zu verteilen würde mir nicht einfallen. Man kann auch ganz schlecht danach suchen - zumindest mit Programmen, die nicht so etwas wie eine Wortsuche oder reguläre Ausdrücke mit Anker für Wortgrenzen haben.
|
ka111
(Themenstarter)
Anmeldungsdatum: 22. Juni 2014
Beiträge: 141
|
rklm Ich bin nur bis Zeile 22 gekommen. 6 bis 11 erscheint völlig unnötig, weil der Wert jeweils nur der Wert des Index mit führenden Nullen auf zwei Stellen aufgefüllt ist. So etwas kann man leichter berechnen (printf '%02d' $n).
Ou, ja dachte nicht das jetzt noch ein neuer Teilnehmer erscheint hier 😀 Es erscheint halt alles ein wenig unlogisch und wie oft das es überflüssige Sachen gibt weis ich nicht genau, gewisses ist auch einfach um eine schöne Auflistung zu haben. Aber am Schluss hat es ja funktioniert, also so verkehrt kann es ja nicht gewesen sein... Nur für jemand anderen ist es wahrscheinlich kaum mehr ersichtlich was ich gemacht habe. War eigentlich auch mehr für user_unknown und seahawk1986, weil sie sich schon die ganze Zeit damit befasst hatten. Edit: Ah du warst sogar auch am Anfang dabei... Ja Hauptsache es funktioniert einfach...
|
user_unknown
Anmeldungsdatum: 10. August 2005
Beiträge: 17552
Wohnort: Berlin
|
Der, die oder das Shebang:
in Zeile 1 ist falsch.
Ja Hauptsache es funktioniert einfach...
Man kann einen Gaul zur Tränke tragen, aber saufen muss er immer noch selbst. Lass zumindest shellcheck nochmal drüberlaufen, und fix die Fehler.
|
ka111
(Themenstarter)
Anmeldungsdatum: 22. Juni 2014
Beiträge: 141
|
Ups, das habe ich beim Kopieren übersehen, natürlich ist Zeile 1 "#!/bin/bash" user_unknown Lass zumindest shellcheck nochmal drüberlaufen, und fix die Fehler.
Ich denk nicht dran (-: wie könnte es den besser sein als es funktioniert gut, das kann nur noch schlechter werden. Vor allem bin ich mir nicht mal sicher ob ich später nicht den ganzen Teil vor dem Hauptscript wieder neu schreibe, und die Werte irgendwo dauerhaft speichere, mit der Möglichkeit einen Korrektur Wert hinzuzufügen, fals ein Servo nicht ganz mittig ist. Dann könnte ich das nochmals neu überarbeiten, und alle Fehler die mir grad auffallen ausbügeln. Jetzt stört mich das nicht, es funktioniert schnell, und ich kann mich anderem widmen. Edit: Aber ich merk mir mal shellcheck für ein andermal, vielleicht weiss ich ja irgendwann mal wirklich nicht grad wo der Fehler liegt.
|