Immer wieder Servos...

1.) Masseschleife durch Induktion? Was meinst du damit?
2.) Wenig Strom ist das bei einem Servo definitiv nicht. Servos nehmen beim Verfahren mehrere Ampere auf (abhängig vom Servo) und das ist nicht wenig.
3.) Du musst dir vor Augen halten das jede Leiterbahn ein Widerstand ist und dieser einen lastabhängigen Spannungsabfall verursacht. Dadurch kann es z.b. zu einem Reset des uC kommen (im schlimmsten Fall).

MfG Hannes

@i_make_it
Davon bin ich weit entfernt! Wenn ich meinen Plan nicht so aufbaue, wie er dann auch tatsächlich verdrahtet wird, kenn ich mich nicht mehr aus, bin ja blutiger Anfänger mit Elektronik... :lol:
Edit: 10 oder mehr Layer, wegen Signalversatz auf die Länge der Leitung achten, da raucht mir der Kopf, wobei ich mich wahrscheinlich schon mit

Zitat:

kapazitive und induktive Kopplungen

beschäftigen werde müssen

@Hannes
1) Masseschleife war falsch geschrieben, die habe ich ja nicht. Aber einen Störstrom könnte ich ja durch Induktion bekommen, oder? (weil das gibt es im Audiobereich ja auch)
2) Der gezogene Strom für die Servos läuft doch bei mir nicht über uC, wegen der extra Stromversorgung, deshalb macht man das doch, oder verstehe ich es falsch?
3) Der uC resetet ja nicht, sondern das Rechtecksignal zitterte am Ende

Danke für eure vielen Infos!

Zu Punkt 2 musst du meinen Punkt 3 lesen => jede Leiterbahn ist ein Widerstand mit lastabhängigem Spannungsabfall
Zu Punkt 3 habe ich geschrieben das im schlimmsten Fall der uC resettet, es können aber auch andere Fälle eintreten (wiebei dir mit den Signalen).
Deswegen Lastkreis und Steuerkreis trennen, Massen an einem Punkt zusammenführen (Sternpunkt).

MfG Hannes

Ist schon einige Zeit her, aber das Thema war ja noch nicht vom Tisch.

Den Kabelsalat habe ich durch Platinen ersetzt. Es gibt jetzt nur noch längere an den Tastern und Servos, weil sie ja weiter weg sind.
Last- und Steuerkreis sind getrennt und Massen habe ich auch sauber zusammengeführt.

Danke für eure Tips und Infos !
Was auch immer es am Ende war es hat sich erledigt, jetzt läuft es !! :D :D

Zur Programmierung von zeitkritischen Sachen habe ich noch Fragen, bei denen ihr mir vielleicht noch mal Tips geben könnt:
Kann man eigentlich irgendwie messen wie lange bestimmte Anweisungen brauchen, oder bleibt da nur testen ?

Viele Anweisungen, die in der ISR ausgeführt werden sollen, habe ich ja eigentlich nicht (gefühlt):
Timer 1

Servo-Laufvariable resetten wenn > Anzahl Servos
3 einfache Berechnungen um am MUX-Shield den richtigen Pin auszulesen
je nach Taster-Status Werte in zwei Arrays schreiben
über eine for() jeweils 1x shiftOut() an insgesamt 3 Register senden
Länge für OCR1B aus dem Array lesen, dem Timer zuweisen und ihn starten

Timer 2

Timer interrupt abschalten
per shiftOut() das Steuersignal wieder abschalten

Anfangs hatte ich den Ablauf noch etwas anders, aufgeblähter, und ich musste die Routinen auf das obige reduzieren sonst war der Zeitablauf gestört und es lief natürlich nicht.
Am schlimmsten waren

Code:

Serial.print() Serial.println()

die ich Anfangs einfach brauchte um meinen Code zu kontrollieren.

Die kürzeste Zeit, die der Arduino in meinem Programm zum Ausführen bis zum nächsten Interrupt hat, sind 0,6 ms - und mich wundert jetzt, dass bei einem Takt von 16 MHz, den der Arduino UNO ja hat, so wenige Zeilen da schon was ausmachen.
Also dass das ein Tick nicht genügt um eine Anweisung auszuführen ist mir klar, aber gibt es Anhaltswerte wonach ich gehen kann? Dass ich abschätzen kann wie viele Anweisungen in eine Zeit x passen?
Wie macht ihr das?

Viele Grüße, Radom

Zitat:

.. Die kürzeste Zeit .. bis zum nächsten Interrupt hat, sind 0,6 ms .. gibt es Anhaltswerte wonach ich gehen kann? Dass ich abschätzen kann wie viele Anweisungen in eine Zeit x passen?
Wie macht ihr das? ..

600 µs bei 16 MHz ergibt 9600 Taktzyklen. Das sind ja nu nicht sooo viel. Nen genauen Zeitbedarf bekommst Du aus der fooxxfile.lls heraus. Darin, in der *.lls steht nämlich neben allen möglichen Dingen auch der (dis-)assemblierte Code Deines Programms, siehe dieses Beispiel aus (m)einen Codevorrat :

Code:

arno_01.elf: file format elf32-avr Sections: Idx Name Size VMA LMA File off Algn 0 .data 00000366 00800100 000019cc 00001a80 2**0 CONTENTS, ALLOC, LOAD, DATA 1 .text 000019cc 00000000 00000000 000000b4 2**1 CONTENTS, ALLOC, LOAD, READONLY, CODE 2 .bss 00000165 00800466 00800466 00001de6 2**0 ALLOC 3 .eeprom 00000001 00810000 00810000 00001de6 2**0 CONTENTS, ALLOC, LOAD, DATA 4 .debug_aranges 00000020 00000000 00000000 00001de7 2**0 CONTENTS, READONLY, DEBUGGING 5 .debug_pubnames 000006d9 00000000 00000000 00001e07 2**0 CONTENTS, READONLY, DEBUGGING 6 .debug_info 000019a4 00000000 00000000 000024e0 2**0 CONTENTS, READONLY, DEBUGGING 7 .debug_abbrev 00000311 00000000 00000000 00003e84 2**0 CONTENTS, READONLY, DEBUGGING 8 .debug_line 0000141d 00000000 00000000 00004195 2**0 CONTENTS, READONLY, DEBUGGING 9 .debug_frame 000002e0 00000000 00000000 000055b4 2**2 CONTENTS, READONLY, DEBUGGING 10 .debug_str 00000649 00000000 00000000 00005894 2**0 CONTENTS, READONLY, DEBUGGING 11 .debug_loc 00000619 00000000 00000000 00005edd 2**0 CONTENTS, READONLY, DEBUGGING 12 .debug_ranges 000000c0 00000000 00000000 000064f6 2**0 CONTENTS, READONLY, DEBUGGING Disassembly of section .text: 00000000 <__vectors>: 0: 0c 94 34 00 jmp 0x68 ; 0x68 <__ctors_end> 4: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 8: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> c: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 10: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 14: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 18: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 1c: 0c 94 6e 02 jmp 0x4dc ; 0x4dc <__vector_7> 20: 0c 94 a0 02 jmp 0x540 ; 0x540 <__vector_8> 24: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 28: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 2c: 0c 94 f4 01 jmp 0x3e8 ; 0x3e8 <__vector_11> 30: 0c 94 2c 02 jmp 0x458 ; 0x458 <__vector_12> 34: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 38: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 3c: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 40: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 44: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 48: 0c 94 90 00 jmp 0x120 ; 0x120 <__vector_18> 4c: 0c 94 bc 00 jmp 0x178 ; 0x178 <__vector_19> 50: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 54: 0c 94 5b 06 jmp 0xcb6 ; 0xcb6 <__vector_21> 58: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 5c: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 60: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> 64: 0c 94 51 00 jmp 0xa2 ; 0xa2 <__bad_interrupt> .. 00000120 <__vector_18>: // ============================================================================== = // ============================================================================== = ISR( USART0_RX_vect ) { 120: 1f 92 push r1 122: 0f 92 push r0 124: 0f b6 in r0, 0x3f ; 63 126: 0f 92 push r0 128: 11 24 eor r1, r1 12a: 8f 93 push r24 12c: 9f 93 push r25 12e: ef 93 push r30 130: ff 93 push r31 u8 i = rx_in; 132: 90 91 af 04 lds r25, 0x04AF ROLLOVER( i, RX0_SIZE ); 136: 9f 5f subi r25, 0xFF ; 255 138: 90 34 cpi r25, 0x40 ; 64 13a: 08 f0 brcs .+2 ; 0x13e <__vector_18+0x1e> 13c: 90 e0 ldi r25, 0x00 ; 0 if( i == rx_out ){ // buffer overflow 13e: 80 91 b0 04 lds r24, 0x04B0 142: 98 17 cp r25, r24 144: 31 f4 brne .+12 ; 0x152 <__vector_18+0x32> URX0_IEN = 0; // disable RX interrupt 146: 80 91 c1 00 lds r24, 0x00C1 14a: 8f 77 andi r24, 0x7F ; 127 14c: 80 93 c1 00 sts 0x00C1, r24 150: 0a c0 rjmp .+20 ; 0x166 <__vector_18+0x46> return; } rx_buff[rx_in] = UDR0; 152: e0 91 af 04 lds r30, 0x04AF 156: f0 e0 ldi r31, 0x00 ; 0 158: 80 91 c6 00 lds r24, 0x00C6 15c: e1 59 subi r30, 0x91 ; 145 15e: fb 4f sbci r31, 0xFB ; 251 160: 80 83 st Z, r24 rx_in = i; 162: 90 93 af 04 sts 0x04AF, r25 } 166: ff 91 pop r31 168: ef 91 pop r30 16a: 9f 91 pop r25 16c: 8f 91 pop r24 16e: 0f 90 pop r0 170: 0f be out 0x3f, r0 ; 63 172: 0f 90 pop r0 174: 1f 90 pop r1 176: 18 95 reti 00000178 <__vector_19>: // ============================================================================= = .. .. // ============================================================================= = .. 000019c8 <_exit>: 19c8: f8 94 cli 000019ca <__stop_program>: 19ca: ff cf rjmp .-2 ; 0x19ca <__stop_program>

Anfangs allerlei Organisation. Beachte die beispielhafte ISR( USART0_RX_vect ), besonders die pushs am Beginn und die pops am Ende der ISR. Die sind blanker Overhead, weil die ISR erstmal alle von ihr benutzten (manchmal nicht benutzte) Register am Stack sichern - pushen - muss. Weil sie ja zu einem beliebigen Zeitpunkt/Codeabschnitt bedient wird, an dem "niemand" weiß, was gerade in den zentralen Registern der ALU steckt. Am Ende des eigentlich "sinnvollen" Codes der ISR werden die entsprechend der ISR-Startsituation gesicherten Register wieder zurückgeladen - gepopt. Zweimal je sieben pushs bzw. pops sind schon mal achtundzwanzig Maschinenzyklen - die aufgewendet werden müssen, damit alles seine Richtigkeit hat (im beispielhaften Controller pro push oder pull jeweils 2 Zyklen).

Dieser Overhead kostet Zeit wie jeder andere Prozessor-Codeschritt. Und so simpel wie eben von mir vorgerechnet kannst Du nun Routine für Routine durchgehen und die einzelnen Zeiten rauslesen (siehe Datenblatt, Instruction Set Summary, hier aus dem Atmel-42735B-ATmega328/P_Datasheet_Complete-11/2016). Dies gilt aber nur dann, wenn nicht innerhalb Deines betrachteten Codes eine - oder mehrere - ISR ausgelöst werden und abgearbeitet werden müssen . . . es sei denn, es geht um einen Abschnitt der z.B. mit cli (); (=Global Interrupt Disable) anfängt und mit sei (); (= Global Interrupt Enable) endet ODER wenn Interrupts z.B. noch garnicht erlaubt sind.

Klar ?